Added 1 solution & modified 3 solutions

varunu28 · varunu28 · commit 872e1b1b7e6f · 2020-02-14T07:04:11.000-08:00
diff --git a/Easy/Convert BST to greater tree.java b/Easy/Convert BST to greater tree.java
@@ -8,18 +8,19 @@
  * }
  */
 class Solution {
-    
-    int sum = 0;
-    public TreeNode convertBST(TreeNode root) {
-        convert(root);
-        return root;
-    }
-    
-    public void convert(TreeNode cur) {
-        if (cur == null) return;
-        convert(cur.right);
-        cur.val += sum;
-        sum = cur.val;
-        convert(cur.left);
+  int updatedVal = 0;
+  public TreeNode convertBST(TreeNode root) {
+    helper(root);
+    return root;
+  }
+  
+  private void helper(TreeNode root) {
+    if (root == null) {
+      return;
     }
+    helper(root.right);
+    updatedVal += root.val;
+    root.val = updatedVal;
+    helper(root.left);
+  }
 }
diff --git a/Easy/Merge two binary trees.java b/Easy/Merge two binary trees.java
@@ -8,17 +8,20 @@
  * }
  */
 class Solution {
-    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
-        if (t1 == null && t2 == null) {
-            return null;
-        }
-        
-        int v = (t1 == null ? 0 : t1.val) + (t2 == null ? 0 : t2.val);
-        TreeNode newNode = new TreeNode(v);
-        
-        newNode.left = mergeTrees(t1==null ? null : t1.left, t2==null ? null : t2.left);
-        newNode.right = mergeTrees(t1==null ? null : t1.right, t2==null ? null : t2.right);
-        
-        return newNode;
+  public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
+    if (t1 == null && t2 == null) {
+      return null;
     }
+    int val = (t1 == null ? 0 : t1.val) + (t2 == null ? 0 : t2.val); 
+    TreeNode root = new TreeNode(val);
+    root.left = mergeTrees(
+      t1 == null ? null : t1.left, 
+      t2 == null ? null : t2.left
+    );
+    root.right = mergeTrees(
+      t1 == null ? null : t1.right, 
+      t2 == null ? null : t2.right
+    );
+    return root;
+  }
 }
diff --git a/Easy/Sum of Root To Leaf Binary Numbers.java b/Easy/Sum of Root To Leaf Binary Numbers.java
@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+  List<String> list;
+  public int sumRootToLeaf(TreeNode root) {
+    list = new ArrayList<>();
+    helper(root, new StringBuilder());
+    int ans = 0;
+    for (String num : list) {
+      ans += getIntegerVal(num);
+    }
+    return ans;
+  }
+  
+  private void helper(TreeNode root, StringBuilder sb) {
+    if (root == null) {
+      return;
+    }
+    sb.append(root.val);
+    if (root.left == null && root.right == null) {
+      list.add(sb.toString());
+    }
+    else {
+      helper(root.left, new StringBuilder(sb.toString()));
+      helper(root.right, new StringBuilder(sb.toString()));
+    }
+  }
+  
+  private int getIntegerVal(String s) {
+    int num = 0;
+    int pow = 1;
+    for (int i = s.length() - 1; i >= 0; i--) {
+      num += Character.getNumericValue(s.charAt(i)) * pow;
+      pow *= 2;
+    }
+    return num;
+  }
+}
diff --git a/Easy/Univalued Binary Tree.java b/Easy/Univalued Binary Tree.java
@@ -8,24 +8,20 @@
  * }
  */
 class Solution {
-    int currVal;
-    public boolean isUnivalTree(TreeNode root) {
-        currVal = Integer.MAX_VALUE;
-        return isUnivalTreeHelper(root);
+  public boolean isUnivalTree(TreeNode root) {
+    if (root == null) {
+      return true;
     }
-    
-    private boolean isUnivalTreeHelper(TreeNode root) {
-        if (root == null) {
-            return true;
-        }
-        
-        if (currVal == Integer.MAX_VALUE) {
-            currVal = root.val;
-        }
-        else if (currVal != root.val) {
-            return false;
-        }
-        
-        return isUnivalTreeHelper(root.left) && isUnivalTreeHelper(root.right);
+    return helper(root, root.val);
+  }
+  
+  private boolean helper(TreeNode root, int val) {
+    if (root == null) {
+      return true;
     }
+    if (root.val != val) {
+      return false;
+    }
+    return helper(root.left, val) && helper(root.right, val);
+  }
 }
