层序遍历的变形(锯齿形遍历)--两种实现(递归和迭代)

题目

题目分析：

递归法解决

用递归法实现，层序遍历需要注意一点：
就是需要通过每层的序号建立对应的数组来存储数据。

代码

class Solution {
private:
    vector<vector<int>> res;
    void DFS(TreeNode* Node, int level) {
        if(!Node) return;
        // 保证每个层级遍历到后都有对应的数组用于存储层序数据，用递归实现层序的必备模板
        if(level >= res.size()) res.push_back(vector<int>());
        //这里是针对该题目的操作，当为偶数层时从数组前面插入元素
        if(level % 2) res[level].insert(res[level].begin(), Node->val);
        //否则在后面插入
        else res[level].push_back(Node->val);
        //前序遍历，优先做最左边的
        DFS(Node->left, level + 1);
        DFS(Node->right, level + 1);
    }
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {    
        DFS(root, 0);
        return res;
    }
};

利用队列迭代(由于需要每次取队尾的元素，所以需要防止每次入队影响每层的遍历)

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>>res;
        if(!root)
            return res;
        vector<TreeNode*>Q;
        Q.push_back(root);
        bool flag = true;
        while(!Q.empty()){
            int size = Q.size();
            vector<int>Rt;
            //每次只存储一层到后面交换，有点像双向BFS的处理
            //这个处理原因是因为每次遍历的是最后的元素，然而最后的元素会在遍历过程中不断变化
            vector<TreeNode*>tmp;
            for(int i=0;i<size;i++){
                TreeNode* s = Q.back();
                Q.pop_back();
                Rt.push_back(s->val);
                //奇偶层处理方式不同
                if(flag){
                    if(s->left)
                        tmp.push_back(s->left);
                    if(s->right)
                        tmp.push_back(s->right);
                }
                else{
                    if(s->right)
                        tmp.push_back(s->right);
                    if(s->left)
                        tmp.push_back(s->left);
                } 
            }
            //三件事：flag更新、换层遍历、更新答案
            flag = !flag;
            Q = tmp;
            res.push_back(Rt);
        }
        return res;
    }
};