solve problem Binary TreeLevel Order Traversal

Author: P-ppc

README.md

@@ -196,6 +196,7 @@ All solutions will be accepted!
 |665|[Non Decreasing Array](https://leetcode-cn.com/problems/non-decreasing-array/description/)|[java/py/js](./algorithms/NonDecreasingArray)|Easy|
 |867|[Transpose Matrix](https://leetcode-cn.com/problems/transpose-matrix/description/)|[java/py/js](./algorithms/TransposeMatrix)|Easy|
 |479|[Largest Palindrome Product](https://leetcode-cn.com/problems/largest-palindrome-product/description/)|[java/py/js](./algorithms/LargestPalindromeProduct)|Easy|
+|102|[Binray Tree Level Order Traversal](https://leetcode-cn.com/problems/binary-tree-level-order-traversal/description/)|[java/py/js](./algorithms/BinrayTreeLevelOrderTraversal)|Medium|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/BinrayTreeLevelOrderTraversal/README.md

@@ -0,0 +1,2 @@
+# Binray Tree Level Order Traversal
+This problem is easy to solve by BFS

algorithms/BinrayTreeLevelOrderTraversal/Solution.java

@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> res = new ArrayList<List<Integer>>();
+        List<TreeNode> stack = new ArrayList<TreeNode>(),
+                       nextStack = new ArrayList<TreeNode>();
+        List<Integer> values = new ArrayList<Integer>();
+        
+        if (root != null) stack.add(root);
+        
+        while (stack.size() > 0) {
+            TreeNode node = stack.get(0);
+            stack.remove(0);
+            values.add(node.val);
+            
+            if (node.left != null) nextStack.add(node.left);
+            if (node.right != null) nextStack.add(node.right);
+            
+            if (stack.size() == 0) {
+                res.add(values);
+                stack = nextStack;
+                values = new ArrayList<Integer>();
+                nextStack = new ArrayList<TreeNode>();
+            }
+        }
+        
+        return res;
+    }
+}

algorithms/BinrayTreeLevelOrderTraversal/solution.js

@@ -0,0 +1,36 @@
+/**
+ * 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) {
+    let res = [],
+        stack = [],
+        nextStack = [],
+        values = []
+    
+    if (root) stack.push(root)
+    
+    while (stack.length > 0) {
+        let node = stack.shift()
+        values.push(node.val)
+        
+        if (node.left) nextStack.push(node.left)
+        if (node.right) nextStack.push(node.right)
+        
+        if (stack.length === 0) {
+            res.push(values)
+            stack = nextStack
+            values = []
+            nextStack = []
+        }
+    }
+    
+    return res
+};

algorithms/BinrayTreeLevelOrderTraversal/solution.py

@@ -0,0 +1,36 @@
+# 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]]
+        """
+        res = []
+        stack = []
+        next_stack = []
+        level_values = []
+        if root: stack.append(root)
+            
+        while len(stack) > 0:
+            node = stack[0]
+            stack = stack[1:]
+            level_values.append(node.val)
+            
+            if node.left:
+                next_stack.append(node.left)
+            if node.right:
+                next_stack.append(node.right)
+            
+            if len(stack) == 0:
+                res.append(level_values)
+                stack = next_stack
+                level_values = []
+                next_stack = []
+        
+        return res