剑指Offer(第二版)：55 - II. 平衡二叉树 54. 二叉搜索树的第k大节点 39. 数组中出现次数超过一半的数字 15.二进制中1的个数 28. 对称的二叉树 65. 不用加减乘除做加法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isBalanced(TreeNode root) {
        if(root == null)
            return true;
        int lefDep = depth(root.left);
        int rigDep = depth(root.right);

        return ((rigDep-lefDep<=1) && (rigDep-lefDep>=-1)) ? (isBalanced(root.left) && isBalanced(root.right)) : false;
    }

    //每个节点的深度
    private int depth(TreeNode node){

        return node == null ? 0 : Math.max(depth(node.left) , depth(node.right)) + 1;
    
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
 
 /**
 解题思路：
    首先我们遍历树，将他们的值放入到数组中，然后排序，再取值， dfs
  */
class Solution {

    //创建列表
    List<Integer> list_arr = new ArrayList<>();

    public int kthLargest(TreeNode root, int k) {
        if(root == null)
            return 0;

        dfs(root);

        //到此列表就填满了值，然后排序


        return list_arr.get(list_arr.size() -k);
    }

    private void dfs(TreeNode node){
        if(node == null)
            return;
        
        dfs(node.left);

        list_arr.add(node.val);

        dfs(node.right);
    }

}

class Solution {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        return nums[nums.length/2];
    }
}

public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        return Integer.bitCount(n);
    }
}

public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        int count = 0;
        while(n!=0){
            count++;
            n = n&(n-1);
        }
        return count;
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null)
            return true;
        return isSubSym(root.left , root.right);
    }
    private boolean isSubSym(TreeNode node1 , TreeNode node2){
        if(node1 == null && node2 == null)
            return true;
        if(node1 == null || node2 == null)
            return false;
        return node1.val == node2.val &&  isSubSym(node1.left , node2.right) && isSubSym(node1.right , node2.left);
    }
}

/**
    底层运算
 */
class Solution {
    public int add(int a, int b) {
        while(b!=0){
            int c = (a & b) << 1 ; //c是进位
            a^=b;  //a为非进位和
            b = c;
        }
        return a;
    }
}