【栈与队列】N叉树的层序遍历 && 二叉树的锯齿形层序遍历 ...

429. N 叉树的层序遍历

429. N 叉树的层序遍历
​ 给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
​ 树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（拜见示例）。
示例 1：

1. 输入：root = [1,null,3,2,4,null,5,6]
2. 输出：[[1],[3,2,4],[5,6]]

复制代码

示例 2：

1. 输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
2. 输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

复制代码

提示：

• 树的高度不会凌驾 1000
  
• 树的节点总数在 [0, 10^4] 之间
  

---

解题思路：队列 + 广度搜索

​ 这道题实在就是 二叉树的层序遍历 的变形，只不过将其左右孩子改成了一个数组来存放孩子节点罢了，我们只需要遍历一下数组即可，其它思路都是一样的，就是使用队列的先进先出特点，每次处理一层，然后根据队列的元素个数控制每层遍历d

1. /*
2. // Definition for a Node.
3. class Node {
4. public:
5.     int val;
6.     vector<Node*> children;
8.     Node() {}
10.     Node(int _val) {
11.         val = _val;
12.     }
14.     Node(int _val, vector<Node*> _children) {
15.         val = _val;
16.         children = _children;
17.     }
18. };
19. */
21. class Solution {
22. public:
23.     vector<vector<int>> levelOrder(Node* root) {
24.         if(root == nullptr)
25.             return {};
26.         
27.         vector<vector<int>> vv; // 结果集
28.         queue<Node*> qe;                // 队列，存放的是树的节点
29.         qe.push(root);
30.         while(!qe.empty())
31.         {
32.             int n = qe.size();
33.             vector<int> v;
34.             for(int i = 0; i < n; ++i)
35.             {
36.                 Node* front = qe.front();
37.                 qe.pop();
38.                 v.push_back(front->val);
40.                 for(int j = 0; j < front->children.size(); ++j) // 将当前节点的所有子节点入队列
41.                     qe.push(front->children[j]);
42.             }
43.             vv.push_back(v); // 别忘了尾插到结果集中
44.         }
45.         return vv;
46.     }
47. };

复制代码

103. 二叉树的锯齿形层序遍历

103. 二叉树的锯齿形层序遍历
​ 给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间瓜代进行）。
示例 1：

1. 输入：root = [3,9,20,null,null,15,7]
2. 输出：[[3],[20,9],[15,7]]

复制代码

示例 2：

1. 输入：root = [1]
2. 输出：[[1]]

复制代码

示例 3：

1. 输入：root = []
2. 输出：[]

复制代码

提示：

• 树中节点数目在范围 [0, 2000] 内
  
• -100 <= Node.val <= 100
  

---

解题思路：队列 + 广度搜索

​ 这道题就是 429. N 叉树的层序遍历 的拓展，假设第一层是根节点那层，那么接下来第二层就需要逆序，第三层就不逆序，如果我们直接在遍历节点的时候控制队列中当前节点的孩子节点插入的话，实在是不太好搞，还有另外一个妙招！
​ 因为我们每次都把每层的遍历结果放在一个数组 v 中呀，那我们只需要在每层数组 v 处理完成之后，判定一下当前是奇数层还是偶数层，如果是偶数层的话，我们就把数组 v 逆序一下插入到 vv 中即可，无非就是 429. N 叉树的层序遍历 这道题多加了仅仅三行代码！

1. /**
2. * Definition for a binary tree node.
3. * struct TreeNode {
4. *     int val;
5. *     TreeNode *left;
6. *     TreeNode *right;
7. *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
8. *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9. *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10. * };
11. */
12. class Solution {
13. public:
14.     vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
15.         if(root == nullptr)
16.             return {};
17.         vector<vector<int>> vv;
18.         queue<TreeNode*> qe;
19.         qe.push(root);
20.         int flag = 1; // 规定奇数表示从左向右遍历，偶数从右往左遍历
21.         while(!qe.empty())
22.         {
23.             vector<int> v;
24.             int n = qe.size();
25.             for(int i = 0; i < n; ++i)
26.             {
27.                 TreeNode* front = qe.front();
28.                 qe.pop();
29.                 v.push_back(front->val);
30.                 if(front->left)
31.                     qe.push(front->left);
32.                 if(front->right)
33.                     qe.push(front->right);
34.             }
35.             
36.             // 如果是偶数的话只需要逆序一下数组即可
37.             if(flag % 2 == 0)
38.                 reverse(v.begin(), v.end());
40.             vv.push_back(v);
41.             flag++;
42.         }
43.         return vv;
44.     }
45. };

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。