Java日记2018-06-11

54. 二叉搜索树的第 K 个结点
    根据二叉搜索树的特点，实行中序遍历，先递归找到最左，然后中间，然后最右，这种情况下可以使用两个额外的cnt res来计数

//54. 二叉搜索树的第 K 个结点
    private static int cnt=0;
    private static TreeNode res ;
    public static TreeNode KthNode(TreeNode root,int k){
        inorder(root,k);
        return res;
    }
    public static void inorder(TreeNode root,int k){
        if(root==null|| cnt>=k) return;
        inorder(root.left,k);
        cnt++;
        System.out.println("root:"+root.val+" cnt:"+cnt);
        if(cnt==k) res=root;
        inorder(root.right,k);
    }

55.1 二叉树的深度
算法容易想，实现居然卡了壳

    public static int depth(TreeNode root){
        if(root==null) return 0;
        return 1+Math.max(depth(root.left), depth(root.right));
                
    }

55.2 平衡二叉树
平衡二叉树左右子树高度差不超过 1,于是有上一题计算的高度可以扩展一下
下面是我的想法

//55.2 平衡二叉树
    public static boolean isBalanced(TreeNode root){
        int left = depth(root.left);
        int right = depth(root.right);
        if(Math.abs(left-right)>1){
            return false;
        }else{
            return true;
        }
    }
    

这个是题解的想法，

private boolean isBalanced = true;

public boolean IsBalanced_Solution(TreeNode root) {
    height(root);
    return isBalanced;
}

private int height(TreeNode root) {
    if (root == null)
        return 0;
    int left = height(root.left);
    int right = height(root.right);
    if (Math.abs(left - right) > 1)
        isBalanced = false;
    return 1 + Math.max(left, right);
}

对了。这样还想到题解最长不重复子串的时候，解释的第一个最长子串是有问题的，导致了我反复想了好久。sign

56. 数组中只出现一次的数字
    举个例子，加入我们输入的数字是｛2，4，3，6，3，2，5，5｝。当我们依次对数组中的每一个数字做异或（相同为0不同为1）运算之后，得到的结果用二进制表示为0010.异或得到的结果中的倒数第二位是1，也就是说两个不相同数字的倒数第二位不一致，根据这个划分，如果数字与0010相与等于0（两位同时为“1”，结果才为“1”，否则为0），即数字的倒数第二位不相同。

根据倒数第二位是否一致划分两组进行异或运算，因为 2 2 3这样的数字异或等于3，很显然两组分别异或后能算出只出现一次结果。

public static void FindNumsAppearOnce(int[] nums, int num1, int num2) {
        int diff = 0;
        for (int num : nums)
            diff ^= num;
        // 得到最右一位
        System.out.println(diff);
        diff &= -diff;

        for (int num : nums) {
            if ((num & diff) == 0) {
                System.out.println("num1 is: " + num);
                num1 ^= num;
            } else
                num2 ^= num;
        }
        System.out.println(num1 + num1);
    }

57.1 和为 S 的两个数字

public ArrayList<Integer> FindNumbersWithSum(int[] array, int sum) {
    int i = 0, j = array.length - 1;
    while (i < j) {
        int cur = array[i] + array[j];
        if (cur == sum)
            return new ArrayList<>(Arrays.asList(array[i], array[j]));
        if (cur < sum)
            i++;
        else
            j--;
    }
    return new ArrayList<>();
}

57.2 和为 S 的连续正数序列
与上个一样都没实现，先放着，手写对照用

public ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum) {
    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
    int start = 1, end = 2;
    int curSum = 3;
    while (end < sum) {
        if (curSum > sum) {
            curSum -= start;
            start++;
        } else if (curSum < sum) {
            end++;
            curSum += end;
        } else {
            ArrayList<Integer> list = new ArrayList<>();
            for (int i = start; i <= end; i++)
                list.add(i);
            ret.add(list);
            curSum -= start;
            start++;
            end++;
            curSum += end;
        }
    }
    return ret;
}