摘要

樹的大部分問題都可以通過遞迴解決，即求一個樹的某個值可以轉化為求左子樹/右子樹的值

二叉樹的最大深度

二叉樹最大深度就是max(左子樹的最大深度,右子樹的最大深度） + 1(根節點)

public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        int left = maxDepth(root.left);
        int right = maxDepth(root.right);
        return left < right ? right + 1: left+1;
    }

驗證二叉搜尋樹

二叉搜尋樹是自左向右的有序樹，可以通過中序遍歷，然後判斷中序遍歷的結果是否有序

   public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }
        List<Integer> values = new ArrayList<Integer>();
        inOrder(root, values);
        for (int i = 0; i < values.size() - 1; i++) {
            if (values.get(i) >= values.get(i + 1)) {
                return false;
            }
        }
        return true;
    }
     // 中序遍歷
     public  void inOrder(TreeNode root, List<Integer> values) {
        if (root == null) {
            return;
        }
        inOrder(root.left, values);
        values.add(root.val);
        inOrder(root.right, values);
    }

對稱二叉樹

對稱二叉樹就是判斷左右子樹對稱，遞迴方法即可

 public boolean isSymmetric(TreeNode root) {
         if (root == null) {
            return true;
        }
        return isNodeSymmetric(root.right, root.left);
    }
    private boolean isNodeSymmetric(TreeNode right, TreeNode left) {
        if (right == null && left == null) {
            return true;
        }
        if (right == null || left == null) {
            return false;
        }
        boolean result = right.val == left.val && isNodeSymmetric(right.right, left.left) &&
                isNodeSymmetric(right.left, left.right);
        return result;
    }

二叉樹的層次遍歷

二叉樹的層次遍歷需要利用額外資料結構佇列，將上一層的節點從左到右放在佇列中，下一層的節點值，就是通過上一層的節點的左右節點得到。

  public List<List<Integer>> levelOrder(TreeNode root) {
          if (root == null) {
            return Collections.emptyList();
        }
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        LinkedList<TreeNode> nextQueue = new LinkedList<TreeNode>();
        queue.add(root);
        List<Integer> level0 = new ArrayList<Integer>();
        level0.add(root.val);
        result.add(level0);
        if (root.left != null) {
            nextQueue.add(root.left);
        }
        if (root.right != null) {
            nextQueue.add(root.right);
        }
        while (!nextQueue.isEmpty()) {
            List<Integer> level = new ArrayList<Integer>();
            queue = (LinkedList<TreeNode>) nextQueue.clone();
            nextQueue.clear();
            while (!queue.isEmpty()) {
                TreeNode node = queue.poll();
                level.add(node.val);
                if (node.left != null) {
                    nextQueue.add(node.left);
                }
                if (node.right != null) {
                    nextQueue.add(node.right);
                }
            }
            if (!level.isEmpty()) {
                result.add(level);
            }
        }
        return result;
    }

上面這個解法有問題，queue其實沒有用，還進行了佇列的深拷貝，空間複雜度高，並且花費的時間比較久，

        if (root == null) {
            return Collections.emptyList();
        }
        List<List<Integer>> result = new ArrayList<List<Integer>>();

        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        List<Integer> level0 = new ArrayList<Integer>();
        level0.add(root.val);
        result.add(level0);
        if (root.left != null) {
            queue.add(root.left);
        }
        if (root.right != null) {
            queue.add(root.right);
        }
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<Integer>();
            int count = queue.size();
            while (count-- > 0) {
                TreeNode node = queue.poll();
                level.add(node.val);
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            if (!level.isEmpty()) {
                result.add(level);
            }
        }
        return result;

將有序陣列轉換為二叉搜尋樹

二叉搜尋樹本身就是有序的，所以將有序陣列轉換為二叉搜尋樹，就是按照左根右的順序構建樹，根節點就是中間的值，使用遞迴來解決

public TreeNode sortedArrayToBST(int[] nums) {
         if (nums == null || nums.length == 0) {
            return null;
        }
        return generateSortedArray(nums, 0, nums.length -1);
    }
      private TreeNode generateSortedArray(int[] nums , int start, int end) {
        if (start > end) {
            return null;
        }
        int mid = (start + end)/2;
        TreeNode head = new TreeNode(nums[mid]);
        head.left = generateSortedArray(nums, start, mid -1);
        head.right = generateSortedArray(nums, mid+1,end);
        return head;
    }