default

  • 二叉树的直径
    • 递归
      递归一想就不会, 二想还不会:)
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
        class Solution {
        int ans = 0;

        public int diameterOfBinaryTree(TreeNode root) {
            traverse(root);
            return ans;
        }

        private int traverse(TreeNode node) {
            if (node == null) {
                return 0;
            }

            int leftDepth = traverse(node.left);
            int rightDepth = traverse(node.right);

            // Update the diameter if the sum of left and right depths is greater than current ans
            ans = Math.max(ans, leftDepth + rightDepth);

            // Return the depth of the current subtree rooted at 'node'
            return 1 + Math.max(leftDepth, rightDepth);
        }
      }
  • 将有序数列转换为平衡高度二叉树
    • 递归 查找中间的数字, 左边递归, 右边递归
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      class Solution {
        public TreeNode sortedArrayToBST(int[] nums) {
            return traverse(nums,0,nums.length-1);

        }
        public TreeNode traverse(int num[],int left,int right){ //!!!!看返回值,构造参数!!!

            if(left>right) return null;

            int mid = (left+right) >> 1 ;

            TreeNode ans = new TreeNode(num[mid]);
            ans.left = traverse(num,left,mid-1);
            ans.right = traverse(num,mid+1,right);
            
            return ans;
        }
      }