tree

Author: idf

src/PathSum/Solution.java

@@ -0,0 +1,56 @@
+package PathSum;
+
+import commons.datastructures.TreeNode;
+
+/**
+ * User: Danyang
+ * Date: 1/19/2015
+ * Time: 19:33
+ * Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.
+ */
+public class Solution {
+    /**
+     * dfs
+     * @param root
+     * @param sum
+     * @return
+     */
+    public boolean hasPathSum_error(TreeNode root, int sum) {
+        if(root==null)
+            return false;
+        return dfs(root, 0, sum, 0);
+    }
+
+    boolean dfs(TreeNode cur, int sum_cur, int sum, int depth) {
+        if(cur==null) {
+            if(sum_cur==sum&&depth>1)
+                return true;
+            else
+                return false;
+        }
+        return dfs(cur.left, sum_cur+cur.val, sum, depth+1) || dfs(cur.right, sum_cur+cur.val, sum, depth+1);
+    }
+
+
+    public boolean hasPathSum(TreeNode root, int sum) {
+        return dfs(root, sum);
+    }
+
+    /**
+     * TreeNode val can be negative
+     * @param c
+     * @param remain
+     * @return
+     */
+    boolean dfs(TreeNode c, int remain) {
+        if(c==null)
+            return false;
+
+        remain -= c.val;
+
+        if(remain==0&&c.left==null&&c.right==null)
+            return true;
+
+        return dfs(c.left, remain) || dfs(c.right, remain);
+    }
+}

src/PathSumII/Solution.java

@@ -0,0 +1,35 @@
+package PathSumII;
+
+import commons.datastructures.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * User: Danyang
+ * Date: 1/19/2015
+ * Time: 19:51
+ */
+public class Solution {
+    public List<List<Integer>> pathSum(TreeNode root, int sum) {
+        List<List<Integer>> ret = new ArrayList<>();
+        dfs(root, new ArrayList<>(), sum, ret);
+        return ret;
+    }
+
+    void dfs(TreeNode c, List<Integer> cur, int remain, List<List<Integer>> ret) {
+        if(c==null)
+            return;
+
+        remain -= c.val;
+        cur.add(c.val);
+        if(remain==0 && c.left==null && c.right==null) {
+            List<Integer> t = new ArrayList<>();
+            t.addAll(cur);
+            ret.add(t);
+        }
+        dfs(c.left, cur, remain, ret);
+        dfs(c.right, cur, remain, ret);
+        cur.remove(cur.size()-1);
+    }
+}

src/SymmetricTree/Solution.java

@@ -0,0 +1,39 @@
+package SymmetricTree;
+
+import commons.datastructures.TreeNode;
+
+/**
+ * User: Danyang
+ * Date: 1/19/2015
+ * Time: 19:21
+ *
+ * Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).
+ */
+public class Solution {
+    /**
+     * iterative: bfs, array sysmetric
+     * recursive: drawing the tree
+     *           1
+     *        2     2
+     *      3  4  4   3
+     *    5 6 7 88 7 6 5
+     * @param root
+     * @return
+     */
+    public boolean isSymmetric(TreeNode root) {
+        if(root==null)
+            return true;
+        return isSymmetric(root.left, root.right);
+    }
+
+    boolean isSymmetric(TreeNode l, TreeNode r) {
+        if(l==null&&r==null)
+            return true;
+        try {
+            return l.val==r.val && isSymmetric(l.left, r.right) && isSymmetric(l.right, r.left);
+        }
+        catch(Exception e) {
+            return false;
+        }
+    }
+}