udpate some solution

Author: dingjikerbo

leetcode/solution/src/DiameterOfBinaryTree.java

@@ -2,23 +2,30 @@ public class DiameterOfBinaryTree {
 
     /**
      * 这题和 124. Binary Tree Maximum Path Sum比较像
-     * 都是分两种情况，一种是必须包括root的，带上必须包括left和right的单边结果;
-     * 还有不是必须包括root的，对比left和right的双边结果
-     * flag为true表示必须包括root，false表示不是必须包括root
      */
     public int diameterOfBinaryTree(TreeNode root) {
         if (root == null) {
             return 0;
         }
-        return dfs(root, false);
+        return dfs(root, new int[1]) - 1;
     }
 
-    public int dfs(TreeNode root, boolean flag) {
+    /**
+     * len表示带上root的最大深度
+     */
+    private int dfs(TreeNode root, int[] len) {
         if (root == null) {
-            return -1;
+            return 0;
         }
-        return flag ? Math.max(dfs(root.left, true) + 1, dfs(root.right, true) + 1) :
-                Math.max(Math.max(dfs(root.left, false), dfs(root.right, false)),
-                        dfs(root.left, true) + 2 + dfs(root.right, true));
+
+        int[] lt = new int[1];
+        int[] rt = new int[1];
+
+        int left = dfs(root.left, lt);
+        int right = dfs(root.right, rt);
+
+        len[0] = Math.max(lt[0], rt[0]) + 1;
+
+        return Math.max(Math.max(left, right), lt[0] + rt[0] + 1);
     }
 }

leetcode/solution/src/TwoSumIV.java

@@ -1,11 +1,15 @@
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 
 /**
  * https://leetcode.com/articles/two-sum-iv/
  */
 public class TwoSumIV {
 
+    /**
+     * 先遍历一遍，生成一个递增序列，再从两端往中间检查
+     */
     public boolean findTarget(TreeNode root, int k) {
         List<Integer> nums = new ArrayList<>();
         inorder(root, nums);
@@ -23,4 +27,23 @@ public void inorder(TreeNode root, List<Integer> nums) {
         nums.add(root.val);
         inorder(root.right, nums);
     }
+
+    /**
+     * 更简单一点，遍历树，用一个hashset记录每个元素
+     * 时间空间都是O(n)
+     */
+    public boolean findTarget2(TreeNode root, int k) {
+        return visit(root, k, new HashSet<>());
+    }
+
+    private boolean visit(TreeNode root, int k, HashSet<Integer> set) {
+        if (root == null) {
+            return false;
+        }
+        if (set.contains(k - root.val)) {
+            return true;
+        }
+        set.add(root.val);
+        return visit(root.left, k, set) || visit(root.right, k, set);
+    }
 }

leetcode/src/Main.java

@@ -6,28 +6,33 @@ public class Main {
 
     public static class Solution {
 
-        public TreeNode constructMaximumBinaryTree(int[] nums) {
-            return helper(nums, 0, nums.length - 1);
+        public int diameterOfBinaryTree(TreeNode root) {
+            if (root == null) {
+                return 0;
+            }
+            return dfs(root, new int[1]) - 1;
         }
 
-        private TreeNode helper(int[] nums, int start, int end) {
-            if (start > end) {
-                return null;
-            }
-            int index, max = start;
-            for (index = start + 1; index <= end; index++) {
-                if (nums[index] > nums[max]) {
-                    max = index;
-                }
+        private int dfs(TreeNode root, int[] len) {
+            if (root == null) {
+                return 0;
             }
-            TreeNode root = new TreeNode(nums[max]);
-            root.left = helper(nums, start, max - 1);
-            root.right = helper(nums, max + 1, end);
-            return root;
+
+            int[] lt = new int[1];
+            int[] rt = new int[1];
+
+            int left = dfs(root.left, lt);
+            int right = dfs(root.right, rt);
+
+            len[0] = Math.max(lt[0], rt[0]) + 1;
+
+            return Math.max(Math.max(left, right), lt[0] + rt[0] + 1);
         }
     }
 
     public static void main(String[] args) {
-
+        Solution s = new Solution();
+        TreeNode root1 = new TreeNode(1);
+        System.out.println(f);
     }
 }