feat: add solutions to lcof problem: No.32.3

Author: yanglbme

lcof/面试题32 - III. 从上到下打印二叉树 III/README.md

@@ -35,6 +35,12 @@
 
 ## 解法
 
+**方法一：BFS**
+
+为了实现锯齿形层序遍历，我们每次将当前层的节点添加到结果数组之前，先判断一下当前结果数组的长度，如果是奇数，就将当前层的节点反转一下。之后把当前层的节点添加到结果数组中即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为二叉树的节点数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -50,23 +56,22 @@
 
 class Solution:
     def levelOrder(self, root: TreeNode) -> List[List[int]]:
+        ans = []
         if root is None:
-            return []
-        q = deque()
-        res = []
-        q.append(root)
+            return ans
+        q = deque([root])
+        ans = []
         while q:
-            size = len(q)
             t = []
-            for _ in range(size):
+            for _ in range(len(q)):
                 node = q.popleft()
                 t.append(node.val)
-                if node.left is not None:
+                if node.left:
                     q.append(node.left)
-                if node.right is not None:
+                if node.right:
                     q.append(node.right)
-            res.append(t if len(res) & 1 == 0 else t[::-1])
-        return res
+            ans.append(t[::-1] if len(ans) & 1 else t)
+        return ans
 ```
 
 ### **Java**
@@ -83,133 +88,151 @@ class Solution:
  */
 class Solution {
     public List<List<Integer>> levelOrder(TreeNode root) {
-        if (root == null) return Collections.emptyList();
+        List<List<Integer>> ans = new ArrayList<>();
+        if (root == null) {
+            return ans;
+        }
         Deque<TreeNode> q = new ArrayDeque<>();
-        List<List<Integer>> res = new ArrayList<>();
         q.offer(root);
         while (!q.isEmpty()) {
-            int size = q.size();
             List<Integer> t = new ArrayList<>();
-            while (size-- > 0) {
+            for (int n = q.size(); n > 0; --n) {
                 TreeNode node = q.poll();
                 t.add(node.val);
-                if (node.left != null) q.offer(node.left);
-                if (node.right != null) q.offer(node.right);
+                if (node.left != null) {
+                    q.offer(node.left);
+                }
+                if (node.right != null) {
+                    q.offer(node.right);
+                }
             }
-            if ((res.size() & 1) == 1) Collections.reverse(t);
-            res.add(t);
+            if (ans.size() % 2 == 1) {
+                Collections.reverse(t);
+            }
+            ans.add(t);
         }
-        return res;
+        return ans;
     }
 }
 ```
 
-### **JavaScript**
+### **C++**
 
-```js
+```cpp
 /**
  * Definition for a binary tree node.
- * function TreeNode(val) {
- *     this.val = val;
- *     this.left = this.right = null;
- * }
- */
-/**
- * @param {TreeNode} root
- * @return {number[][]}
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
  */
-var levelOrder = function (root) {
-    if (!root) return [];
-    let queue = [root];
-    let res = [];
-    let depth = 0;
-    let dir = true;
-    while (queue.length) {
-        let len = queue.length;
-        for (let i = 0; i < len; i++) {
-            let node = queue.shift();
-            if (!node) continue;
-            if (!res[depth]) res[depth] = [];
-            if (dir) {
-                res[depth].push(node.val);
-            } else {
-                res[depth].unshift(node.val);
+class Solution {
+public:
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        vector<vector<int>> ans;
+        if (!root) {
+            return ans;
+        }
+        queue<TreeNode*> q{{root}};
+        while (!q.empty()) {
+            vector<int> t;
+            for (int n = q.size(); n; --n) {
+                auto node = q.front();
+                q.pop();
+                t.push_back(node->val);
+                if (node->left) {
+                    q.push(node->left);
+                }
+                if (node->right) {
+                    q.push(node->right);
+                }
             }
-            queue.push(node.left, node.right);
+            if (ans.size() & 1) {
+                reverse(t.begin(), t.end());
+            }
+            ans.emplace_back(t);
         }
-        depth++;
-        dir = !dir;
+        return ans;
     }
-    return res;
 };
 ```
 
 ### **Go**
 
 ```go
-func levelOrder(root *TreeNode) [][]int {
-    if root == nil {
-        return nil
-    }
-    res := [][]int{}
-    queue := []*TreeNode{}
-    queue = append(queue,root)
-    level := 0
-    for len(queue) != 0 {
-        size := len(queue)
-        ans := []int{}
-        //size记录每层大小,level记录层数
-        for size > 0 {
-            cur := queue[0]
-            if level & 1 == 0 {
-                ans = append(ans, cur.Val)
-            } else {
-                ans = append([]int{cur.Val},ans...)
-            }
-
-            queue = queue[1:]
-            size--
-            if cur.Left != nil {
-                queue = append(queue, cur.Left)
-            }
-            if cur.Right != nil {
-                queue = append(queue, cur.Right)
-            }
-        }
-        level++
-        res = append(res, ans)
-    }
-    return res
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func levelOrder(root *TreeNode) (ans [][]int) {
+	if root == nil {
+		return
+	}
+	q := []*TreeNode{root}
+	for len(q) > 0 {
+		t := []int{}
+		for n := len(q); n > 0; n-- {
+			node := q[0]
+			q = q[1:]
+			t = append(t, node.Val)
+			if node.Left != nil {
+				q = append(q, node.Left)
+			}
+			if node.Right != nil {
+				q = append(q, node.Right)
+			}
+		}
+		if len(ans)&1 == 1 {
+			for i, j := 0, len(t)-1; i < j; i, j = i+1, j-1 {
+				t[i], t[j] = t[j], t[i]
+			}
+		}
+		ans = append(ans, t)
+	}
+	return
 }
 ```
 
-### **C++**
+### **JavaScript**
 
-```cpp
-class Solution {
-public:
-    vector<vector<int>> levelOrder(TreeNode* root) {
-        vector<vector<int>> ans;
-        if (root == NULL) return ans;
-        queue<TreeNode*> q;
-        q.push(root);
-        bool flag = false;
-        while (!q.empty()) {
-            int n = q.size();
-            vector<int> v;
-            for (int i = 0; i < n; ++i) {
-                TreeNode* node = q.front();
-                q.pop();
-                v.emplace_back(node->val);
-                if (node->left) q.push(node->left);
-                if (node->right) q.push(node->right);
-            }
-            if (flag) reverse(v.begin(), v.end());
-            flag = !flag;
-            ans.emplace_back(v);
-        }
+```js
+/**
+ * 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) {
+    const ans = [];
+    if (!root) {
         return ans;
     }
+    const q = [root];
+    while (q.length) {
+        const t = [];
+        for (let n = q.length; n; --n) {
+            const { val, left, right } = q.shift();
+            t.push(val);
+            left && q.push(left);
+            right && q.push(right);
+        }
+        if (ans.length & 1) {
+            t.reverse();
+        }
+        ans.push(t);
+    }
+    return ans;
 };
 ```
 
@@ -331,25 +354,22 @@ public class Solution {
         }
         var q = new Queue<TreeNode>();
         q.Enqueue(root);
-        int i = 0;
         while (q.Count > 0) {
-            var tmp = new List<int>();
-            int x = q.Count;
-            for (int j = 0; j < x; j++) {
+            var t = new List<int>();
+            for (int n = q.Count; n > 0; --n) {
                 var node = q.Dequeue();
-                tmp.Add(node.val);
+                t.Add(node.val);
                 if (node.left != null) {
                     q.Enqueue(node.left);
                 }
                 if (node.right != null) {
                     q.Enqueue(node.right);
                 }
             }
-            if (i % 2 == 1) {
-                tmp.Reverse();
+            if (ans.Count % 2 == 1) {
+                t.Reverse();
             }
-            ans.Add(tmp);
-            i += 1;
+            ans.Add(t);
         }
         return ans;
     }

lcof/面试题32 - III. 从上到下打印二叉树 III/Solution.cpp

@@ -1,25 +1,38 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
 class Solution {
 public:
     vector<vector<int>> levelOrder(TreeNode* root) {
         vector<vector<int>> ans;
-        if (root == NULL) return ans;
-        queue<TreeNode*> q;
-        q.push(root);
-        bool flag = false;
+        if (!root) {
+            return ans;
+        }
+        queue<TreeNode*> q{{root}};
         while (!q.empty()) {
-            int n = q.size();
-            vector<int> v;
-            for (int i = 0; i < n; ++i) {
-                TreeNode* node = q.front();
+            vector<int> t;
+            for (int n = q.size(); n; --n) {
+                auto node = q.front();
                 q.pop();
-                v.emplace_back(node->val);
-                if (node->left) q.push(node->left);
-                if (node->right) q.push(node->right);
+                t.push_back(node->val);
+                if (node->left) {
+                    q.push(node->left);
+                }
+                if (node->right) {
+                    q.push(node->right);
+                }
+            }
+            if (ans.size() & 1) {
+                reverse(t.begin(), t.end());
             }
-            if (flag) reverse(v.begin(), v.end());
-            flag = !flag;
-            ans.emplace_back(v);
+            ans.emplace_back(t);
         }
         return ans;
     }
-};
+};