add more solutions (up to #145)

Author: alexwawl

solutions/100_SameTree.js

@@ -0,0 +1,52 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {boolean}
+ */
+var isSameTree = function(p, q) {
+    //Recursive solution
+    // function helper(p, q){
+    //     if(!p && !q){
+    //         return true
+    //     }
+    //     if(!p || !q){
+    //         return false
+    //     }
+    //     if(p.val != q.val){
+    //         return false
+    //     }
+    //     return helper(p.left,q.left) && helper(p.right,q.right)
+    // }
+    // return helper(p,q)
+    var queue = [[p,q]];
+    function check(p,q){
+        if(!p && !q){
+                return true;
+        }
+        if(!p || !q){
+            return false
+        }
+        if(p.val != q.val){
+            return false
+        }
+        return true;
+    }
+    while(queue.length > 0){
+        let [p, q] = queue.pop();
+        if(!check(p,q)){
+            return false;
+        }
+        if(p){
+             queue.push([p.left, q.left]);
+             queue.push([p.right, q.right]);
+        }
+    }
+    return true;
+};

solutions/101_SymmetricTree.js

@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isSymmetric = function(root) {
+    function helper(left, right){
+        if(!left && !right){
+            return true
+        }
+        if(!left || !right){
+            return false
+        }
+        if(left.val == right.val){
+            let n_left = helper(left.left, right.right)
+            let n_right = helper(left.right, right.left)
+            return n_left && n_right
+        } else {
+            return false
+        }
+    }
+    if(!root){
+        return true
+    }
+    return helper(root.left,root.right)
+};

solutions/102_BinaryTreeLevelOrderTraversal.js

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+var levelOrder = function(root) {
+    // so okay, we should go from top to bottom, from left to write.
+    // until our queue is full get data from it and put it to result. (add data to queue from right to left)
+    // when queue is empty add childs from roots
+    var result = []
+    function helper(node,level){
+        if(!node) { 
+            return;
+        }
+        if(!result[level]) {
+            result[level] = []
+        }
+        result[level].push(node.val);
+        helper(node.left,level+1);
+        helper(node.right,level+1);
+    }
+    helper(root,0)
+    return result;
+};

solutions/102_BinaryTreeLevelOrderTraversal.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 levelOrder(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        result = []
+        #self.bfs_rec(root,0, result)
+        self.bfs_iter(root,result)
+        return result
+        
+    def bfs_rec(self, root, level, result):
+        if not root:
+            return;
+        if level < len(result):
+            result.append([])
+        
+        result[level].append(root.val)
+        self.bfs_rec(root.left, level + 1, result)
+        self.bfs_rec(root.right, level+1, result)
+    
+    def bfs_iter(self, root, result):
+        if not root:
+            return
+        queue = [root]
+        
+        while queue:
+            tmp = []
+            for _ in range(len(queue)):
+                node = queue.pop(0)
+                if node.left:
+                    queue.append(node.left)
+                if node.right:
+                    queue.append(node.right)
+                tmp.append(node.val)
+            result.append(tmp)
+        

solutions/104_MaximumDepthofBinaryTree.js

@@ -0,0 +1,24 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxDepth = function(root) {
+    function helper(head,acc){
+        if(!head){
+            return acc+0
+        }
+        if(!head.left && !head.right){
+            return acc+1
+        }
+        return Math.max(helper(head.left, acc+1),helper(head.right,acc+1))
+    }
+    
+    return helper(root,0)
+};

solutions/104_MaximumDepthofBinaryTree.py

@@ -0,0 +1,21 @@
+# 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 maxDepth(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        return self.dfs_max(root,0)
+    
+    def dfs_max(self, root, accum):
+        if not root:
+            return accum
+        if not root.left and not root.right:
+            return accum+1
+        return max(self.dfs_max(root.left,accum+1), self.dfs_max(root.right, accum+1))

solutions/107_BinaryTreeLevelOrderTraversalII.js

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+var levelOrderBottom = function(root) {
+    var result = [];
+    var queue = [root];
+    if(!root){
+        return []
+    }
+    while(queue.length != 0){
+        let size = queue.length;
+        let tmp = []
+        for(let i = 0;i<size;i++){
+            let node = queue.shift();
+            tmp.push(node.val);
+            if(node.left){queue.push(node.left)}
+            if(node.right){queue.push(node.right)}
+        }
+        result.push(tmp)
+    }
+    return result.reverse()
+};

solutions/108_ConvertSortedArraytoBinarySearchTree .js

@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {number[]} nums
+ * @return {TreeNode}
+ */
+var sortedArrayToBST = function(nums) {
+    function helper(nums){
+        if(nums.length == 0){
+            return null
+        }
+        let half = Math.floor(nums.length / 2);
+        let root = new TreeNode(nums[half])
+        root.left = helper(nums.slice(0,half))
+        //because we are using half as Value.
+        root.right = helper(nums.slice(half+1))
+        return root
+    }
+    return helper(nums)
+};

solutions/110_BalancedBinaryTree.js

@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isBalanced = function(root) {
+    function helper(root){
+        if(!root){
+            return 0;
+        }
+        
+        let left = helper(root.left);
+        let right = helper(root.right);
+        if(left == -1 || right == -1 || Math.abs(left-right) > 1){
+            return -1;
+        }
+        return 1 + Math.max(left,right)
+    }
+    return helper(root) != -1
+};

solutions/111_MinimumDepthofBinaryTree.js

@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var minDepth = function(root) {
+    function dfs(root, count){
+        if(!root){
+            return 0;
+        }
+        if(!root.left || !root.right){
+            return Math.max(dfs(root.left, count+1),dfs(root.right, count+1)) + 1
+        }
+        if(root){
+            return Math.min(dfs(root.left, count+1),dfs(root.right, count+1)) + 1
+        }
+    }
+    return dfs(root, 0);
+};

solutions/111_MinimumDepthofBinaryTree.py

@@ -0,0 +1,23 @@
+# 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 minDepth(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        return self.min(root)
+    
+    def min(self, root):
+        if not root:
+            return 0
+        if not root.left or not root.right:
+            return max(self.min(root.left), self.min(root.right)) + 1
+        if root:
+            return min(self.min(root.left), self.min(root.right)) + 1
+        

solutions/112_PathSum.js

@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} sum
+ * @return {boolean}
+ */
+var hasPathSum = function(root, sum) {
+    function helper(node, sum){
+        if(!node){
+            return false;
+        }
+        if(!node.left && !node.right && sum == node.val){
+            return true
+        }
+        let left = helper(node.left, sum-node.val);
+        let right = helper(node.right, sum-node.val);
+        return left || right
+    }
+    let result = helper(root, sum);
+    return result;
+};