练习题（二）

1.二叉树平衡检查

实现一个函数，检查二叉树是否平衡，平衡的定义如下，对于树中的任意一个结点，其两颗子树的高度差不超过1。

给定指向树根结点的指针TreeNode* root，请返回一个bool，代表这棵树是否平衡。

思路：先判断根结点是否为null，如果为null，则直接返回true。再判断是否只有一个节点，如果是，则直接返回true；否则返回false。然后通过计算根节点的左右子树之差，如果差的绝对值小于等于1（小于2），则返回false；否则返回true。

import java.util.*;

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class Balance {
    public boolean isBalance(TreeNode root) {
       if(root==null){
           return true;
       }
        
        if(root.left==null&&root.right==null){
            return true;
        }
        int left=getHeight(root.left);
        int right=getHeight(root.right);
        if(Math.abs(left-right)<2){
            return true;
        }else{
            return false;
        }
    }
    private static int getHeight(TreeNode root){
        if(root==null){
            return 0;
        }
        if(root.left==null&&root.right==null){
            return 1;
        }
        int max=Math.max(getHeight(root.left),getHeight(root.right));
        return max+1;
    }
}

2.守形数

守形数是这样一种整数，它的平方的低位部分等于它本身。 比如25的平方是625，低位部分是25，因此25是一个守形数。 编一个程序，判断N是否为守形数。

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            String s=sc.next();
            int n=Integer.parseInt(s);
            int square=n*n;
            String str=String.valueOf(square);
            if(str.length()==s.length()){//n=2/3
                System.out.println("No!");
                continue;
            }
            if(str.substring(str.length()-s.length()).equals(s)){
                System.out.println("Yes!");
            }else{
                System.out.println("No!");
            }
        }
        sc.close();
    }
}

3.整数与IP地址的转换

原理：ip地址的每段可以看成是一个0-255的整数，把每段拆分成一个二进制形式组合起来，然后把这个二进制数转变成
一个长整数。
举例：一个ip地址为10.0.3.193
每段数字             相对应的二进制数
10                   00001010
0                    00000000
3                    00000011
193                  11000001
组合起来即为：00001010 00000000 00000011 11000001,转换为10进制数就是：167773121，即该IP地址转换后的数字就是它了。

输入描述：

1 输入IP地址
2 输入10进制型的IP地址

输出描述：

1 输出转换成10进制的IP地址
2 输出转换后的IP地址

如：输入：10.0.3.193 167969729    输出：167773121 10.3.3.193

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
        String str = sc.next();//IP地址
        long d =Long.parseLong(sc.next());
        
        long res = IpToInt(str);
        System.out.println(res);
        
        String r=intToIp(d);
        System.out.println(r);
        }
        sc.close();
    }

    //将十进制数转为IP地址
    private static String intToIp(long d) {
        //将十进制化为二进制然后每8位读一个整数
        StringBuilder sb = new StringBuilder();//167969729
        StringBuilder res = new StringBuilder();
        while (d > 0) {
            sb.append(d % 2);
            d /= 2;
        }//83984864
        //sb="1000000111100010001"
        //从后开始，每8位读一位整数
        StringBuilder stringBuilder = new StringBuilder();
        while (stringBuilder.length() + sb.length() < 32) {
            stringBuilder.append("0");
        }
        String s = stringBuilder.append(sb.reverse().toString()).toString();//00001000001111000000000000000101
        for (int i = 0; i < s.length(); i += 8) {
            String r = s.substring(i, i + 8);//
            int l = 0;
            int k = 1;
            for (int j = r.length() - 1; j >= 0; j--) {
                if (r.charAt(j) == '1') {
                    l += k;
                }
                k *= 2;
            }
            res.append(l).append(".");
        }
        return res.toString().substring(0, res.length() - 1);
    }

    //将IP地址转为十进制数
    private static long IpToInt(String str) {
        String[] s = str.split("\\.");
        String[] arr = new String[s.length];
        StringBuilder sb = new StringBuilder();//存储所有的二进制字符串
        for (int i = 0; i < arr.length; i++) {
            int k = Integer.parseInt(s[i]);//10 0 3 193
            arr[i] = toBin(k);//转为二进制 0000 1010
            sb.append(arr[i]);
        }
//        System.out.println(sb.toString());//00001010000000000000001111000001
        return Long.parseLong(sb.toString(),2);//2为基数
    }

    //将i转为二进制字符串拼接 10 -> 0101->1010
    private static String toBin(int i) {
        StringBuilder sb = new StringBuilder();
        while (i != 0) {
            sb.append(i % 2);
            i /= 2;
        }
        //0101
        while (sb.length() < 8) {
            //在前面补充0
            sb.append("0");
        }
        //0101 0000
        return sb.reverse().toString();//0000 1010
    }
}

4.密码验证合格程序

密码要求：1.长度超过8位。2.包括大小写字母，数字，其它符号，以上四种至少三种。3.不能有相同长度超2的子串重复。

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            String pw=sc.nextLine();//密码
            if(isLength(pw)&&isCharacter(pw)&&isRepeated(pw)){
                System.out.println("OK");
            }else{
                System.out.println("NG");
            }
        }
    }
    private static boolean isLength(String pw){
        return pw.length()>8?true:false;
    }
    //判断大小写字母、数字或其它符号，至少一种或多种
    private static boolean isCharacter(String pw){
        int up=0;//记录大写字母
        int low=0;//记录小写字母
        int num=0;//记录数字
        int other=0;//记录其它符号
        for(int i=0;i<pw.length();i++){
            char c=pw.charAt(i);
            if(c>='a'&&c<='z'){
                low=1;
            }else if(c>='A'&&c<='Z'){
                up=1;
            }else if(c>='0'&&c<='9'){
                num=1;
            }else{
                other=1;
            }
        }
        if(up+low+num+other>=3){
            return true;
        }else{
            return false;
        }
    }
    //判断是否有超过长度超过2的子串重复
    private static boolean isRepeated(String pw){
        for(int i=0;i<pw.length()-3;i++){
            String sub=pw.substring(i,i+3);
            if(pw.substring(i+3).contains(sub)){
                return false;
            }
        }
        return true;
    }
}