Day 20 | 654. Maximum Binary Tree | 617. Merge Two Binary Trees | 700.Search in a Binary Search Tree

Day 1 | 704. Binary Search | 27. Remove Element | 35. Search Insert Position | 34. First and Last Position of Element in Sorted Array
Day 2 | 977. Squares of a Sorted Array | 209. Minimum Size Subarray Sum | 59. Spiral Matrix II
Day 3 | 203. Remove Linked List Elements | 707. Design Linked List | 206. Reverse Linked List
Day 4 | 24. Swap Nodes in Pairs| 19. Remove Nth Node From End of List| 160.Intersection of Two Lists
Day 6 | 242. Valid Anagram | 349. Intersection of Two Arrays | 202. Happy Numbe | 1. Two Sum
Day 7 | 454. 4Sum II | 383. Ransom Note | 15. 3Sum | 18. 4Sum
Day 8 | 344. Reverse String | 541. Reverse String II | 替换空格 | 151.Reverse Words in a String | 左旋转字符串
Day 9 | 28. Find the Index of the First Occurrence in a String | 459. Repeated Substring Pattern
Day 10 | 232. Implement Queue using Stacks | 225. Implement Stack using Queue
Day 11 | 20. Valid Parentheses | 1047. Remove All Adjacent Duplicates In String | 150. Evaluate RPN
Day 13 | 239. Sliding Window Maximum | 347. Top K Frequent Elements
Day 14 | 144.Binary Tree Preorder Traversal | 94.Binary Tree Inorder Traversal| 145.Binary Tree Postorder Traversal
Day 15 | 102. Binary Tree Level Order Traversal | 226. Invert Binary Tree | 101. Symmetric Tree
Day 16 | 104.MaximumDepth of BinaryTree| 111.MinimumDepth of BinaryTree| 222.CountComplete TreeNodes
Day 17 | 110. Balanced Binary Tree | 257. Binary Tree Paths | 404. Sum of Left Leaves
Day 18 | 513. Find Bottom Left Tree Value | 112. Path Sum | 105&106. Construct Binary Tree

---

LeetCode 654. Maximum Binary Tree

Question Link
1、Normal Solution（define new arrays）

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        if(nums.length == 0)
            return null;
        if(nums.length == 1)
            return new TreeNode(nums[0]);

        // Find the max value and the index of the max value
        int maxValue = 0;
        int maxValueIndx = 0;
        for(int i = 0; i < nums.length; i++){
            if(nums[i] > maxValue){
                maxValue = nums[i];
                maxValueIndx = i;
            }
        }
        TreeNode node = new TreeNode(maxValue);
        
        // Find the left subtree and thee right subtree
        int[] nums_left = new int[maxValueIndx];
        int[] nums_right = new int[nums.length - maxValueIndx - 1];
        System.arraycopy(nums, 0, nums_left, 0, maxValueIndx);
        System.arraycopy(nums, maxValueIndx+1, nums_right, 0, nums.length - maxValueIndx - 1);

        node.left = constructMaximumBinaryTree(nums_left);
        node.right = constructMaximumBinaryTree(nums_right);

        return node;
    }       
}

2、Normal Solution（does’t define new arrays）

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return traversal(nums, 0, nums.length); // left closed right opened
    }

    TreeNode traversal(int[] nums, int leftIndex, int rightIndex){
        if(rightIndex - leftIndex < 1)
            return null;
        if(rightIndex - leftIndex == 1)
            return new TreeNode(nums[leftIndex]);

        // Find the max value and the index of the max value
        int maxValue = 0;
        int maxValueIndex = 0;
        for(int i = leftIndex; i < rightIndex; i++){
            if(nums[i] > maxValue){
                maxValue = nums[i];
                maxValueIndex = i;
            }
        }
        TreeNode node = new TreeNode(maxValue);
        node.left = traversal(nums, leftIndex, maxValueIndex);
        node.right = traversal(nums, maxValueIndex + 1, rightIndex);

        return node;
    }       
}

• left closed right open

LeetCode 617. Merge Two Binary Trees

Question Link

1、Recursion Method

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if(root1 == null)
            return root2;
        if(root2 == null)
            return root1;

        TreeNode node = new TreeNode(root1.val + root2.val);
        node.left = mergeTrees(root1.left, root2.left);
        node.right = mergeTrees(root1.right, root2.right);
        return node;
    }
}

2、Iterative Method

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if(root1 == null)
            return root2;
        if(root2 == null)
            return root1;
        Deque<TreeNode> deque = new LinkedList<>();
        deque.offer(root1);
        deque.offer(root2);
        while(!deque.isEmpty()){
            TreeNode node1 = deque.poll();
            TreeNode node2 = deque.poll();
            node1.val += node2.val;
            if(node1.left!=null && node2.left!=null){
                deque.offer(node1.left);
                deque.offer(node2.left);
            }
            if(node1.right!=null && node2.right!=null){
                deque.offer(node1.right);
                deque.offer(node2.right);
            }
            if(node1.left==null && node2.left!=null){
                node1.left = node2.left;
            }
            if(node1.right==null && node2.right!=null){
                node1.right = node2.right;
            }
        }

        return root1;
    }
}

LeetCode 700. Search in a Binary Search Tree

Question Link

1、Recursion Method

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        if(root == null || root.val == val)
            return root;
        TreeNode node = null;
        if(root.val > val)
            node = searchBST(root.left, val);
        if(root.val < val)
            node = searchBST(root.right, val);
        return node;
    }
}

2、Iterative Method

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        while(root != null){
            if(root.val == val)
                return root;
            else if(root.val > val)
                root = root.left;
            else if(root.val < val)
                root = root.right;
        }
        return null;
    }
}

LeetCode 98. Validate Binary Search Tree

Question Link

class Solution {
    long max_val = Long.MIN_VALUE;
    public boolean isValidBST(TreeNode root) {
        if(root == null) return true;
        
        boolean left = isValidBST(root.left);
        
        if(root.val > max_val)
            max_val = root.val;
        else
            return false;

        boolean right = isValidBST(root.right);
        return left&&right;
    }
}

A null tree can be thought of as all kinds of trees.