538_Convert_BST_to_Greater_Tree and 617_Merge_Two_Binary_Trees

Author: qiyuangong

java/400_Nth_Digit.java

@@ -10,7 +10,8 @@ public int findNthDigit(int n) {
 			count *= 10;
 			start *= 10;
 		}
-
 		start += (n - 1) / len;
 		String s = Integer.toString(start);
 		return Character.getNumericValue(s.charAt((n - 1) % len));
+    }
+}

java/538_Convert_BST_to_Greater_Tree.java

@@ -0,0 +1,39 @@
+class Solution {
+    // https://leetcode.com/problems/convert-bst-to-greater-tree/solution/
+    // private int sum = 0;
+
+    // public TreeNode convertBST(TreeNode root) {
+    //     if (root != null) {
+    //         convertBST(root.right);
+    //         sum += root.val;
+    //         root.val = sum;
+    //         convertBST(root.left);
+    //     }
+    //     return root;
+    // }
+    
+    public TreeNode convertBST(TreeNode root) {
+        int sum = 0;
+        TreeNode node = root;
+        Stack<TreeNode> stack = new Stack<TreeNode>();
+
+        while (!stack.isEmpty() || node != null) {
+            /* push all nodes up to (and including) this subtree's maximum on
+             * the stack. */
+            while (node != null) {
+                stack.add(node);
+                node = node.right;
+            }
+
+            node = stack.pop();
+            sum += node.val;
+            node.val = sum;
+
+            /* all nodes with values between the current and its parent lie in
+             * the left subtree. */
+            node = node.left;
+        }
+
+        return root;
+    }
+}

java/617_Merge_Two_Binary_Trees.java

@@ -0,0 +1,46 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
+        if (t1 == null)
+            return t2;
+        if (t2 == null)
+            return t1;
+        t1.val += t2.val;
+        t1.left = mergeTrees(t1.left, t2.left);
+        t1.right = mergeTrees(t1.right, t2.right);
+        return t1;
+    }
+
+    // public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
+    //     if (t1 == null)
+    //         return t2;
+    //     Stack < TreeNode[] > stack = new Stack < > ();
+    //     stack.push(new TreeNode[] {t1, t2});
+    //     while (!stack.isEmpty()) {
+    //         TreeNode[] t = stack.pop();
+    //         if (t[0] == null || t[1] == null) {
+    //             continue;
+    //         }
+    //         t[0].val += t[1].val;
+    //         if (t[0].left == null) {
+    //             t[0].left = t[1].left;
+    //         } else {
+    //             stack.push(new TreeNode[] {t[0].left, t[1].left});
+    //         }
+    //         if (t[0].right == null) {
+    //             t[0].right = t[1].right;
+    //         } else {
+    //             stack.push(new TreeNode[] {t[0].right, t[1].right});
+    //         }
+    //     }
+    //     return t1;
+    // }
+}

python/538_Convert_BST_to_Greater_Tree.py

@@ -0,0 +1,34 @@
+class Solution(object):
+    # https://leetcode.com/problems/convert-bst-to-greater-tree/solution/
+    # def __init__(self):
+    #     self.total = 0
+
+    # def convertBST(self, root):
+    #     if root is not None:
+    #         self.convertBST(root.right)
+    #         self.total += root.val
+    #         root.val = self.total
+    #         self.convertBST(root.left)
+    #     return root
+
+    def convertBST(self, root):
+        total = 0
+        
+        node = root
+        stack = []
+        while stack or node is not None:
+            # push all nodes up to (and including) this subtree's maximum on
+            # the stack.
+            while node is not None:
+                stack.append(node)
+                node = node.right
+
+            node = stack.pop()
+            total += node.val
+            node.val = total
+
+            # all nodes with values between the current and its parent lie in
+            # the left subtree.
+            node = node.left
+
+        return root

python/617_Merge_Two_Binary_Trees.py

@@ -0,0 +1,41 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def mergeTrees(self, t1, t2):
+        """
+        :type t1: TreeNode
+        :type t2: TreeNode
+        :rtype: TreeNode
+        """
+        if t1 is None:
+            return t2
+        if t2 is None:
+            return t1
+        t1.val += t2.val
+        t1.left = self.mergeTrees(t1.left, t2.left)
+        t1.right = self.mergeTrees(t1.right, t2.right)
+        return t1
+
+    # def mergeTrees(self, t1, t2):
+    #     if t1 is None:
+    #         return t2
+    #     stack = [(t1, t2)]
+    #     while len(stack) != 0:
+    #         n1, n2 = stack.pop()
+    #         if n1 is None or n2 is None:
+    #             continue
+    #         n1.val += n2.val
+    #         if n1.left is None:
+    #             n1.left = n2.left
+    #         else:
+    #             stack.insert(0, (n1.left, n2.left))
+    #         if n1.right is None:
+    #             n1.right = n2.right
+    #         else:
+    #             stack.insert(0, (n1.right, n2.right))
+    #     return t1