力扣 103. 二叉树的锯齿形层序遍历 [内存优化]
给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[20,9],[15,7]]示例 2：
输入：root = [1]
输出：[[1]]示例 3：
输入：root = []
输出：[]提示：
- 树中节点数目在范围
[0, 2000]内 -100 <= Node.val <= 100
题解
优化历程
使用递归做，发现内存消耗比较高，看了官方的，内存消耗也高，使用vector替代deque，最后reverse来节约翻转标志位位内存，也只是达到对半开的效果。
寻找到用vector代替且节约reverse标志位的方法，但是优化程度仍然不够，所以使用int数组来替代vector，终于有大幅提升了。
下面是各方法的详细思路与代码。
递归
写一个层序遍历的递归函数，并依次判断记录节点。
查看代码
class Solution {
public:
void work(vector<vector<int>>& vec,TreeNode *p,int cnt){//int记录当前层数
if(p==nullptr)
return;
if(cnt>=vec.size())//如果层数比size大，说明是新的一层
{
vector<int> tmp;
tmp.push_back(p->val);
vec.push_back(tmp);
}
else{//原有的一层，直接访问更新
vec[cnt].push_back(p->val);
}
work(vec,p->right,cnt+1);
work(vec,p->left,cnt+1);
}
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int>> res;
work(res,root,0);
for(int i=2;i<res.size();i+=2){//reverse需要翻转的部分
reverse(res[i].begin(),res[i].end());
}
return res;
}
};官方
使用队列记录每一层的节点，每次只处理一层，至于反转的问题采用双端队列处理，无需额外reverse，下面有详细注释
查看代码
class Solution {
public:
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int>> res;
if(root==nullptr){
return res;
}
bool ifReverse=false;//标志位：是否翻转当前层
queue<TreeNode*> que;//存放每一层的节点
que.push(root);
while(!que.empty()){
int len=que.size();
deque<int> layer;//记录每一层的节点
for(int i=0;i<len;i++){//处理当前层的节点
TreeNode * cur=que.front();//取出当前层的一个节点
que.pop();
//处理此节点：记录val和处理左右子节点
if(ifReverse)//当前层需要翻转，就利用deque，从头部放入，实现逆序
layer.push_front(cur->val);
else
layer.push_back(cur->val);//正序
//放入子节点，还是先左后右的顺序
if(cur->left)
que.push(cur->left);
if(cur->right)
que.push(cur->right);
}
ifReverse=!ifReverse;//每层处理结束,标志位更新
res.emplace_back((vector<int>){layer.begin(),layer.end()});//放入每层的节点值
}
return res;
}
};内存优化
思路和官方一样，只是做了下面两个改动：
1.使用que的size为存放当前层存放节点值的数组赋长度int *layer = new int[len];//len为que的大小，是变量
2.在存入res的时候将int数组转化(vector<int>){layer,layer+len}//将int数组转化为vector
查看代码
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int>> res;
if(root==nullptr){
return res;
}
queue<TreeNode*> que;//存放每一层的节点
que.push(root);
bool ifReverse=false;//标志位：是否翻转当前层
int len;
while(!que.empty()){
len=que.size();
int *layer = new int[len];//记录每一层的节点，使用int数组
for(int i=0;i<len;i++){//处理当前层的节点
TreeNode * cur=que.front();//取出当前层的一个节点
que.pop();
//处理此节点：记录val和处理左右子节点
layer[ifReverse ? len -i - 1 : i] = cur -> val;//根据标志位确定放入正序还是逆序
//放入子节点，还是先左后右的顺序
if(cur->left)
que.push(cur->left);
if(cur->right)
que.push(cur->right);
}
ifReverse=!ifReverse;//每层处理结束,标志位更新
res.emplace_back((vector<int>){layer,layer+len});//将int数组转化为vector
}
return res;
}
};负优化(替换queue)
如果根据这里的方法，使用vector替换queue，效果其实下降了。
查看代码
class Solution {
public:
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int>> res;
if(root==nullptr){
return res;
}
bool ifReverse=false;//标志位：是否翻转当前层
vector<TreeNode*> arr;//存放每一层的节点
arr.emplace_back(root);
while(!arr.empty()){
int len=arr.size();
int *layer=new int[len];
vector<TreeNode *> tmp;//记录下一层节点
for(int i=0;i<len;i++){//处理当前层的节点
TreeNode* cur=arr[i];
//处理此节点：记录val和处理左右子节点
layer[ifReverse ? len -i - 1 : i] = cur -> val;//根据标志位确定放入正序还是逆序
//放入子节点，还是先左后右的顺序
if(cur->left)
tmp.emplace_back(cur->left);
if(cur->right)
tmp.emplace_back(cur->right);
}
ifReverse=!ifReverse;//每层处理结束,标志位更新
res.emplace_back((vector<int>){layer,layer+len});//放入每层的节点值
arr = move(tmp);//将下一层节点全部移动给arr
}
return res;
}
};