feat: add solutions to lc problem: No.0103

No.0103.Binary Tree Zigzag Level Order Traversal

Author: yanglbme

solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README.md

@@ -44,6 +44,12 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：BFS**
+
+为了实现锯齿形层序遍历，需要在层序遍历的基础上增加一个标志位 `left`，用于标记当前层的节点值的顺序。如果 `left` 为 `true`，则当前层的节点值按照从左到右的顺序存入结果数组 `ans` 中；如果 `left` 为 `false`，则当前层的节点值按照从右到左的顺序存入结果数组 `ans` 中。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为二叉树的节点数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -58,25 +64,24 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
+    def zigzagLevelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        ans = []
         if root is None:
-            return []
-        left, ans = False, []
+            return ans
         q = deque([root])
+        ans = []
+        left = 1
         while q:
-            n = len(q)
             t = []
-            for _ in range(n):
+            for _ in range(len(q)):
                 node = q.popleft()
                 t.append(node.val)
                 if node.left:
                     q.append(node.left)
                 if node.right:
                     q.append(node.right)
-            if left:
-                t.reverse()
-            ans.append(t)
-            left = not left
+            ans.append(t if left else t[::-1])
+            left ^= 1
         return ans
 ```
 
@@ -102,17 +107,17 @@ class Solution:
  */
 class Solution {
     public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+        List<List<Integer>> ans = new ArrayList<>();
         if (root == null) {
-            return Collections.emptyList();
+            return ans;
         }
         Deque<TreeNode> q = new ArrayDeque<>();
         q.offer(root);
-        boolean left = false;
-        List<List<Integer>> ans = new ArrayList<>();
+        boolean left = true;
         while (!q.isEmpty()) {
             List<Integer> t = new ArrayList<>();
-            for (int i = 0, n = q.size(); i < n; ++i) {
-                TreeNode node = q.pollFirst();
+            for (int n = q.size(); n > 0; --n) {
+                TreeNode node = q.poll();
                 t.add(node.val);
                 if (node.left != null) {
                     q.offer(node.left);
@@ -121,7 +126,7 @@ class Solution {
                     q.offer(node.right);
                 }
             }
-            if (left) {
+            if (!left) {
                 Collections.reverse(t);
             }
             ans.add(t);
@@ -149,22 +154,22 @@ class Solution {
 class Solution {
 public:
     vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
-        if (!root) return {};
-        queue<TreeNode*> q {{root}};
         vector<vector<int>> ans;
-        bool left = false;
+        if (!root) return ans;
+        queue<TreeNode*> q{{root}};
+        int left = 1;
         while (!q.empty()) {
             vector<int> t;
-            for (int i = 0, n = q.size(); i < n; ++i) {
+            for (int n = q.size(); n; --n) {
                 auto node = q.front();
                 q.pop();
-                t.push_back(node->val);
+                t.emplace_back(node->val);
                 if (node->left) q.push(node->left);
                 if (node->right) q.push(node->right);
             }
-            if (left) reverse(t.begin(), t.end());
-            ans.push_back(t);
-            left = !left;
+            if (!left) reverse(t.begin(), t.end());
+            ans.emplace_back(t);
+            left ^= 1;
         }
         return ans;
     }
@@ -182,17 +187,15 @@ public:
  *     Right *TreeNode
  * }
  */
-func zigzagLevelOrder(root *TreeNode) [][]int {
+func zigzagLevelOrder(root *TreeNode) (ans [][]int) {
 	if root == nil {
-		return nil
+		return
 	}
-	var ans [][]int
-	var q = []*TreeNode{root}
-	left := false
+	q := []*TreeNode{root}
+	left := true
 	for len(q) > 0 {
-		var t []int
-		n := len(q)
-		for i := 0; i < n; i++ {
+		t := []int{}
+		for n := len(q); n > 0; n-- {
 			node := q[0]
 			q = q[1:]
 			t = append(t, node.Val)
@@ -203,18 +206,15 @@ func zigzagLevelOrder(root *TreeNode) [][]int {
 				q = append(q, node.Right)
 			}
 		}
-		if left {
-			i, j := 0, n-1
-			for i < j {
+		if !left {
+			for i, j := 0, len(t)-1; i < j; i, j = i+1, j-1 {
 				t[i], t[j] = t[j], t[i]
-				i++
-				j--
 			}
 		}
 		ans = append(ans, t)
 		left = !left
 	}
-	return ans
+	return
 }
 ```
 
@@ -234,15 +234,15 @@ func zigzagLevelOrder(root *TreeNode) [][]int {
  * @return {number[][]}
  */
 var zigzagLevelOrder = function (root) {
+    const ans = [];
     if (!root) {
-        return [];
+        return ans;
     }
-    let ans = [];
-    let q = [root];
-    let left = false;
+    const q = [root];
+    let left = 1;
     while (q.length) {
-        let t = [];
-        for (let i = 0, n = q.length; i < n; ++i) {
+        const t = [];
+        for (let n = q.length; n; --n) {
             const node = q.shift();
             t.push(node.val);
             if (node.left) {
@@ -252,11 +252,11 @@ var zigzagLevelOrder = function (root) {
                 q.push(node.right);
             }
         }
-        if (left) {
+        if (!left) {
             t.reverse();
         }
         ans.push(t);
-        left = !left;
+        left ^= 1;
     }
     return ans;
 };

solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README_EN.md

@@ -50,25 +50,24 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
+    def zigzagLevelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        ans = []
         if root is None:
-            return []
-        left, ans = False, []
+            return ans
         q = deque([root])
+        ans = []
+        left = 1
         while q:
-            n = len(q)
             t = []
-            for _ in range(n):
+            for _ in range(len(q)):
                 node = q.popleft()
                 t.append(node.val)
                 if node.left:
                     q.append(node.left)
                 if node.right:
                     q.append(node.right)
-            if left:
-                t.reverse()
-            ans.append(t)
-            left = not left
+            ans.append(t if left else t[::-1])
+            left ^= 1
         return ans
 ```
 
@@ -92,17 +91,17 @@ class Solution:
  */
 class Solution {
     public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+        List<List<Integer>> ans = new ArrayList<>();
         if (root == null) {
-            return Collections.emptyList();
+            return ans;
         }
         Deque<TreeNode> q = new ArrayDeque<>();
         q.offer(root);
-        boolean left = false;
-        List<List<Integer>> ans = new ArrayList<>();
+        boolean left = true;
         while (!q.isEmpty()) {
             List<Integer> t = new ArrayList<>();
-            for (int i = 0, n = q.size(); i < n; ++i) {
-                TreeNode node = q.pollFirst();
+            for (int n = q.size(); n > 0; --n) {
+                TreeNode node = q.poll();
                 t.add(node.val);
                 if (node.left != null) {
                     q.offer(node.left);
@@ -111,7 +110,7 @@ class Solution {
                     q.offer(node.right);
                 }
             }
-            if (left) {
+            if (!left) {
                 Collections.reverse(t);
             }
             ans.add(t);
@@ -139,22 +138,22 @@ class Solution {
 class Solution {
 public:
     vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
-        if (!root) return {};
-        queue<TreeNode*> q {{root}};
         vector<vector<int>> ans;
-        bool left = false;
+        if (!root) return ans;
+        queue<TreeNode*> q{{root}};
+        int left = 1;
         while (!q.empty()) {
             vector<int> t;
-            for (int i = 0, n = q.size(); i < n; ++i) {
+            for (int n = q.size(); n; --n) {
                 auto node = q.front();
                 q.pop();
-                t.push_back(node->val);
+                t.emplace_back(node->val);
                 if (node->left) q.push(node->left);
                 if (node->right) q.push(node->right);
             }
-            if (left) reverse(t.begin(), t.end());
-            ans.push_back(t);
-            left = !left;
+            if (!left) reverse(t.begin(), t.end());
+            ans.emplace_back(t);
+            left ^= 1;
         }
         return ans;
     }
@@ -172,17 +171,15 @@ public:
  *     Right *TreeNode
  * }
  */
-func zigzagLevelOrder(root *TreeNode) [][]int {
+func zigzagLevelOrder(root *TreeNode) (ans [][]int) {
 	if root == nil {
-		return nil
+		return
 	}
-	var ans [][]int
-	var q = []*TreeNode{root}
-	left := false
+	q := []*TreeNode{root}
+	left := true
 	for len(q) > 0 {
-		var t []int
-		n := len(q)
-		for i := 0; i < n; i++ {
+		t := []int{}
+		for n := len(q); n > 0; n-- {
 			node := q[0]
 			q = q[1:]
 			t = append(t, node.Val)
@@ -193,18 +190,15 @@ func zigzagLevelOrder(root *TreeNode) [][]int {
 				q = append(q, node.Right)
 			}
 		}
-		if left {
-			i, j := 0, n-1
-			for i < j {
+		if !left {
+			for i, j := 0, len(t)-1; i < j; i, j = i+1, j-1 {
 				t[i], t[j] = t[j], t[i]
-				i++
-				j--
 			}
 		}
 		ans = append(ans, t)
 		left = !left
 	}
-	return ans
+	return
 }
 ```
 
@@ -224,15 +218,15 @@ func zigzagLevelOrder(root *TreeNode) [][]int {
  * @return {number[][]}
  */
 var zigzagLevelOrder = function (root) {
+    const ans = [];
     if (!root) {
-        return [];
+        return ans;
     }
-    let ans = [];
-    let q = [root];
-    let left = false;
+    const q = [root];
+    let left = 1;
     while (q.length) {
-        let t = [];
-        for (let i = 0, n = q.length; i < n; ++i) {
+        const t = [];
+        for (let n = q.length; n; --n) {
             const node = q.shift();
             t.push(node.val);
             if (node.left) {
@@ -242,11 +236,11 @@ var zigzagLevelOrder = function (root) {
                 q.push(node.right);
             }
         }
-        if (left) {
+        if (!left) {
             t.reverse();
         }
         ans.push(t);
-        left = !left;
+        left ^= 1;
     }
     return ans;
 };