Binary Tree Zigzag Level Order Traversal

Author: P-ppc

README.md

@@ -296,6 +296,7 @@ All solutions will be accepted!
 |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|
 |513|[Find Bottom Left Tree Value](https://leetcode-cn.com/problems/find-bottom-left-tree-value/description/)|[java/py/js](./algorithms/FindBottomLeftTreeValue)|Medium|
+|103|[Binary Tree Zigzag Level Order Traversal](https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal/description/)|[java/py/js](./algorithms/BinaryTreeZigzagLevelOrderTraversal)|Medium|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/BinaryTreeZigzagLevelOrderTraversal/README.md

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

algorithms/BinaryTreeZigzagLevelOrderTraversal/Solution.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 {
+    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+        if (root == null)
+            return new ArrayList<List<Integer>>();
+        
+        List<List<Integer>> res = new ArrayList<List<Integer>>();
+        List<Integer> values = new ArrayList<Integer>();
+        LinkedList<TreeNode> stack = new LinkedList<TreeNode>(),
+                             nextStack = new LinkedList<TreeNode>();
+        int direction = 1;
+        stack.add(root);
+        
+        while (stack.size() > 0) {
+            TreeNode node = stack.poll();
+            if (direction == 1)
+                values.add(node.val);
+            else
+                values.add(0, node.val);
+            
+            if (node.left != null)
+                nextStack.add(node.left);
+            if (node.right != null)
+                nextStack.add(node.right);
+            
+            if (stack.size() == 0) {
+                direction = direction == 1 ? 0 : 1;
+                res.add(values);
+                values = new ArrayList<Integer>();
+                stack = nextStack;
+                nextStack = new LinkedList<TreeNode>();
+            }
+        }
+        
+        return res;
+    }
+}

algorithms/BinaryTreeZigzagLevelOrderTraversal/solution.js

@@ -0,0 +1,44 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+var zigzagLevelOrder = function(root) {
+    let stack = [],
+        nextStack = [],
+        direction = 1,
+        values = [],
+        res = []
+    
+    if (root)
+        stack.push(root)
+    
+    while (stack.length > 0) {
+        let node = stack.shift()
+        if (direction)
+            values.push(node.val)
+        else
+            values.unshift(node.val)
+        
+        if (node.left)
+            nextStack.push(node.left)
+        if (node.right)
+            nextStack.push(node.right)
+        
+        if (stack.length == 0) {
+            direction = direction ? 0 : 1
+            res.push(values)
+            values = []
+            stack = nextStack
+            nextStack = []
+        }
+    }
+    
+    return res
+};

algorithms/BinaryTreeZigzagLevelOrderTraversal/solution.py

@@ -0,0 +1,42 @@
+# 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 zigzagLevelOrder(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        stack = []
+        if root:
+            stack.append(root)
+        next_stack = []
+        direction = 1
+        values = []
+        res = []
+        
+        while len(stack) > 0:
+            node = stack[0]
+            stack.remove(node)
+            if direction:
+                values.append(node.val)
+            else:
+                values.insert(0, node.val)
+            
+            if node.left:
+                next_stack.append(node.left)
+            if node.right:
+                next_stack.append(node.right)
+            
+            if len(stack) == 0:
+                direction = 0 if direction else 1
+                res.append(values)
+                values = []
+                stack = next_stack
+                next_stack = []
+        
+        return res