solve problem Add One Row To Tree

Author: P-ppc

README.md

@@ -294,6 +294,7 @@ All solutions will be accepted!
 |153|[Find Minimum In Rotated Sorted Array](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/description/)|[java/py/js](./algorithms/FindMinimumInRotatedSortedArray)|Medium|
 |34|[Find First And Last Position Of Element In Sorted Array](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/description/)|[java/py/js](./algorithms/FindFirstAndLastPositionOfElementInSortedArray)|Medium|
 |75|[Sort Colors](https://leetcode-cn.com/problems/sort-colors/description/)|[java/py/js](./algorithms/SortColors)|Medium|
+|623|[Add One Row To Tree](https://leetcode-cn.com/problems/add-one-row-to-tree/description/)|[java/py/js](./algorithms/AddOneRowToTree)|Medium|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/AddOneRowToTree/README.md

@@ -0,0 +1,2 @@
+# Add One Row To Tree
+This problem is easy to solve by BFS

algorithms/AddOneRowToTree/Solution.java

@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode addOneRow(TreeNode root, int v, int d) {
+        if (d == 1) {
+            TreeNode node = new TreeNode(v);
+            node.left = root;
+            return node;
+        }
+
+        int depth = 1;
+        LinkedList<TreeNode> stack = new LinkedList<TreeNode>(),
+                             nextStack = new LinkedList<TreeNode>();
+        stack.push(root);
+
+        while (depth < d - 1) {
+            TreeNode node = stack.pop();
+            if (node.left != null)
+                nextStack.push(node.left);
+            if (node.right != null)
+                nextStack.push(node.right);
+            if (stack.size() == 0) {
+                stack = nextStack;
+                nextStack = new LinkedList<TreeNode>();
+                depth++;
+            }
+        }
+
+        while (stack.size() > 0) {
+            TreeNode node = stack.pop(),
+                left = new TreeNode(v),
+                right = new TreeNode(v);
+            left.left = node.left;
+            node.left = left;
+            right.right = node.right;
+            node.right = right;
+        }
+
+        return root;
+    }
+}

algorithms/AddOneRowToTree/solution.js

@@ -0,0 +1,49 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} v
+ * @param {number} d
+ * @return {TreeNode}
+ */
+var addOneRow = function(root, v, d) {
+    if (d == 1) {
+        let node = new TreeNode(v)
+        node.left = root
+        return node
+    }
+    
+    let depth = 1,
+        stack = [ root ],
+        nextStack = []
+    
+    while (depth < d - 1) {
+        let node = stack.pop()
+        if (node.left)
+            nextStack.push(node.left)
+        if (node.right)
+            nextStack.push(node.right)
+        if (stack.length == 0) {
+            stack = nextStack
+            nextStack = []
+            depth++
+        }
+    }
+    
+    while (stack.length > 0) {
+        let node = stack.pop(),
+            left = new TreeNode(v),
+            right = new TreeNode(v)
+        left.left = node.left
+        node.left = left
+        right.right = node.right
+        node.right = right
+    }
+    
+    return root
+};

algorithms/AddOneRowToTree/solution.py

@@ -0,0 +1,44 @@
+# 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 addOneRow(self, root, v, d):
+        """
+        :type root: TreeNode
+        :type v: int
+        :type d: int
+        :rtype: TreeNode
+        """
+        if d == 1:
+            node = TreeNode(v)
+            node.left = root
+            return node
+        
+        depth = 1
+        stack = [ root ]
+        next_stack = []
+        while depth < d - 1:
+            node = stack.pop()
+            if node.left:
+                next_stack.append(node.left)
+            if node.right:
+                next_stack.append(node.right)
+            if len(stack) == 0:
+                stack = next_stack
+                next_stack = []
+                depth += 1
+                
+        while len(stack) > 0:
+            node = stack.pop()
+            left = TreeNode(v)
+            left.left = node.left
+            node.left = left
+            right = TreeNode(v)
+            right.right = node.right
+            node.right = right
+        
+        return root