feat: update solutions to lcof problems: 32 - |,32 - ||,32 - |||

- 面试题32 - I. 从上到下打印二叉树
- 面试题32 - II. 从上到下打印二叉树 II
- 面试题32 - III. 从上到下打印二叉树 III

Author: YangFong

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

@@ -156,31 +156,35 @@ func levelOrder(root *TreeNode) []int {
 ### **C++**
 
 ```cpp
+/**
+ * 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<int> levelOrder(TreeNode* root) {
-        vector<int> ret;
-        if (!root) {
-            return ret;
-        }
-
+    vector<int> levelOrder(TreeNode *root) {
+        vector<int> res;
         queue<TreeNode *> q;
-        q.push(root);
-
+        if (root != nullptr) {
+            q.push(root);
+        }
         while (!q.empty()) {
-            auto head = q.front();
+            TreeNode *node = q.front();
             q.pop();
-            ret.push_back(head->val);
-            if (head->left) {
-                q.push(head->left);
+            if (node->left != nullptr) {
+                q.push(node->left);
             }
-
-            if (head->right) {
-                q.push(head->right);
+            if (node->right != nullptr) {
+                q.push(node->right);
             }
+            res.push_back(node->val);
         }
-
-        return ret;
+        return res;
     }
 };
 ```
@@ -207,15 +211,12 @@ function levelOrder(root: TreeNode | null): number[] {
     if (root == null) {
         return res;
     }
-
-    const arr = [root];
-    let i = 0;
-    while (i < arr.length) {
-        const { val, left, right } = arr[i];
+    const queue = [root];
+    while (queue.length !== 0) {
+        const { val, left, right } = queue.shift();
         res.push(val);
-        left && arr.push(left);
-        right && arr.push(right);
-        i++;
+        left && queue.push(left);
+        right && queue.push(right);
     }
     return res;
 }
@@ -245,7 +246,6 @@ function levelOrder(root: TreeNode | null): number[] {
 use std::rc::Rc;
 use std::cell::RefCell;
 use std::collections::VecDeque;
-
 impl Solution {
     pub fn level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<i32> {
         let mut res = Vec::new();

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

@@ -7,31 +7,25 @@
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
-
 class Solution {
 public:
-    vector<int> levelOrder(TreeNode* root) {
-        vector<int> ret;
-        if (!root) {
-            return ret;
-        }
-
+    vector<int> levelOrder(TreeNode *root) {
+        vector<int> res;
         queue<TreeNode *> q;
-        q.push(root);
-
+        if (root != nullptr) {
+            q.push(root);
+        }
         while (!q.empty()) {
-            auto head = q.front();
+            TreeNode *node = q.front();
             q.pop();
-            ret.push_back(head->val);
-            if (head->left) {
-                q.push(head->left);
+            if (node->left != nullptr) {
+                q.push(node->left);
             }
-
-            if (head->right) {
-                q.push(head->right);
+            if (node->right != nullptr) {
+                q.push(node->right);
             }
+            res.push_back(node->val);
         }
-
-        return ret;
+        return res;
     }
 };

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

@@ -19,7 +19,6 @@
 use std::rc::Rc;
 use std::cell::RefCell;
 use std::collections::VecDeque;
-
 impl Solution {
     pub fn level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<i32> {
         let mut res = Vec::new();

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

@@ -17,15 +17,12 @@ function levelOrder(root: TreeNode | null): number[] {
     if (root == null) {
         return res;
     }
-
-    const arr = [root];
-    let i = 0;
-    while (i < arr.length) {
-        const { val, left, right } = arr[i];
+    const queue = [root];
+    while (queue.length !== 0) {
+        const { val, left, right } = queue.shift();
         res.push(val);
-        left && arr.push(left);
-        right && arr.push(right);
-        i++;
+        left && queue.push(left);
+        right && queue.push(right);
     }
     return res;
 }

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

@@ -219,21 +219,19 @@ function levelOrder(root: TreeNode | null): number[][] {
     if (root == null) {
         return res;
     }
-    const levelFn = (nodes: TreeNode[]) => {
-        if (nodes.length === 0) {
-            return res;
+    const queue = [root];
+    while (queue.length !== 0) {
+        const n = queue.length;
+        const tmp = new Array(n);
+        for (let i = 0; i < n; i++) {
+            const { val, left, right } = queue.shift();
+            tmp[i] = val;
+            left && queue.push(left);
+            right && queue.push(right);
         }
-        const nextNodes = [];
-        res.push(
-            nodes.map(({ val, left, right }) => {
-                left && nextNodes.push(left);
-                right && nextNodes.push(right);
-                return val;
-            }),
-        );
-        return levelFn(nextNodes);
-    };
-    return levelFn([root]);
+        res.push(tmp);
+    }
+    return res;
 }
 ```
 
@@ -261,29 +259,29 @@ function levelOrder(root: TreeNode | null): number[][] {
 use std::rc::Rc;
 use std::cell::RefCell;
 use std::collections::VecDeque;
-
 impl Solution {
     pub fn level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
         let mut res = Vec::new();
         if root.is_none() {
             return res;
         }
-        let mut nodes = VecDeque::new();
-        nodes.push_back(root.unwrap());
-        while !nodes.is_empty() {
-            let mut values = Vec::new();
-            for _ in 0..nodes.len() {
-                let node = nodes.pop_front().unwrap();
-                let mut node = node.borrow_mut();
-                values.push(node.val);
+        let mut queue = VecDeque::new();
+        queue.push_back(root);
+        while !queue.is_empty() {
+            let n = queue.len();
+            let mut vals = Vec::with_capacity(n);
+            for _ in 0..n {
+                let mut node = queue.pop_front().unwrap();
+                let mut node = node.as_mut().unwrap().borrow_mut();
+                vals.push(node.val);
                 if node.left.is_some() {
-                    nodes.push_back(node.left.take().unwrap())
+                    queue.push_back(node.left.take());
                 }
                 if node.right.is_some() {
-                    nodes.push_back(node.right.take().unwrap())
+                    queue.push_back(node.right.take());
                 }
             }
-            res.push(values);
+            res.push(vals);
         }
         res
     }

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

@@ -19,29 +19,29 @@
 use std::rc::Rc;
 use std::cell::RefCell;
 use std::collections::VecDeque;
-
 impl Solution {
     pub fn level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
         let mut res = Vec::new();
         if root.is_none() {
             return res;
         }
-        let mut nodes = VecDeque::new();
-        nodes.push_back(root.unwrap());
-        while !nodes.is_empty() {
-            let mut values = Vec::new();
-            for _ in 0..nodes.len() {
-                let node = nodes.pop_front().unwrap();
-                let mut node = node.borrow_mut();
-                values.push(node.val);
+        let mut queue = VecDeque::new();
+        queue.push_back(root);
+        while !queue.is_empty() {
+            let n = queue.len();
+            let mut vals = Vec::with_capacity(n);
+            for _ in 0..n {
+                let mut node = queue.pop_front().unwrap();
+                let mut node = node.as_mut().unwrap().borrow_mut();
+                vals.push(node.val);
                 if node.left.is_some() {
-                    nodes.push_back(node.left.take().unwrap())
+                    queue.push_back(node.left.take());
                 }
                 if node.right.is_some() {
-                    nodes.push_back(node.right.take().unwrap())
+                    queue.push_back(node.right.take());
                 }
             }
-            res.push(values);
+            res.push(vals);
         }
         res
     }

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

@@ -17,19 +17,17 @@ function levelOrder(root: TreeNode | null): number[][] {
     if (root == null) {
         return res;
     }
-    const levelFn = (nodes: TreeNode[]) => {
-        if (nodes.length === 0) {
-            return res;
+    const queue = [root];
+    while (queue.length !== 0) {
+        const n = queue.length;
+        const tmp = new Array(n);
+        for (let i = 0; i < n; i++) {
+            const { val, left, right } = queue.shift();
+            tmp[i] = val;
+            left && queue.push(left);
+            right && queue.push(right);
         }
-        const nextNodes = [];
-        res.push(
-            nodes.map(({ val, left, right }) => {
-                left && nextNodes.push(left);
-                right && nextNodes.push(right);
-                return val;
-            }),
-        );
-        return levelFn(nextNodes);
-    };
-    return levelFn([root]);
+        res.push(tmp);
+    }
+    return res;
 }

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

@@ -235,21 +235,20 @@ function levelOrder(root: TreeNode | null): number[][] {
         return res;
     }
     let isEven = false;
-    const levelFn = (nodes: TreeNode[]) => {
-        if (nodes.length === 0) {
-            return res;
+    const queue = [root];
+    while (queue.length !== 0) {
+        const n = queue.length;
+        const vals = new Array(n);
+        for (let i = 0; i < n; i++) {
+            const { val, left, right } = queue.shift();
+            vals[i] = val;
+            left && queue.push(left);
+            right && queue.push(right);
         }
-        const nextNodes = [];
-        const values = nodes.map(({ val, left, right }) => {
-            left && nextNodes.push(left);
-            right && nextNodes.push(right);
-            return val;
-        });
-        res.push(isEven ? values.reverse() : values);
+        res.push(isEven ? vals.reverse() : vals);
         isEven = !isEven;
-        return levelFn(nextNodes);
-    };
-    return levelFn([root]);
+    }
+    return res;
 }
 ```
 
@@ -277,34 +276,34 @@ function levelOrder(root: TreeNode | null): number[][] {
 use std::rc::Rc;
 use std::cell::RefCell;
 use std::collections::VecDeque;
-
 impl Solution {
     pub fn level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
         let mut res = Vec::new();
         if root.is_none() {
             return res;
         }
-        let mut nodes = VecDeque::new();
-        nodes.push_back(root.unwrap());
+        let mut queue = VecDeque::new();
+        queue.push_back(root);
         let mut is_even = false;
-        while !nodes.is_empty() {
-            let mut values = Vec::new();
-            for _ in 0..nodes.len() {
-                let node = nodes.pop_front().unwrap();
-                let mut node = node.borrow_mut();
-                values.push(node.val);
+        while !queue.is_empty() {
+            let n = queue.len();
+            let mut vals = Vec::with_capacity(n);
+            for _ in 0..n {
+                let mut node = queue.pop_front().unwrap();
+                let mut node = node.as_mut().unwrap().borrow_mut();
+                vals.push(node.val);
                 if node.left.is_some() {
-                    nodes.push_back(node.left.take().unwrap())
+                    queue.push_back(node.left.take());
                 }
                 if node.right.is_some() {
-                    nodes.push_back(node.right.take().unwrap())
+                    queue.push_back(node.right.take());
                 }
             }
             if is_even {
-                values.reverse()
+                vals.reverse();
             }
-            res.push(values);
-            is_even = !is_even
+            res.push(vals);
+            is_even = !is_even;
         }
         res
     }