leetcode103. 蛇形打印二叉树/锯齿形层次遍历

BFS

层级遍历+蛇形输出

思路：
1、使用广度优先遍历，将二叉树所有节点存放于一个双端队列中。
2、使用分隔符（空节点）将层级分离。
3、使用bool控制每一行的输出顺序即可。

执行用时：8 ms
内存消耗：11.5 MB

/**
 * 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:
    void BFS(deque<TreeNode*>& deq, int& index)
    {
        while (index < deq.size())
        {
            TreeNode* cur = deq[index];
            if (cur == nullptr && index == deq.size()-1)
                return;
            else if(cur == nullptr)
                deq.push_back(nullptr);
            else
            {
                if (cur->left) 
                    deq.push_back(cur->left);
                if (cur->right) 
                    deq.push_back(cur->right);
            }
            index++;
        }
    }
    void toVector(deque<TreeNode*>& deq,vector<vector<int>>& ret)
    {
        if(deq.size() <= 0) return;
        bool forwardPrintf = true;

        int index1 = 0;
        int index2 = 0;
        vector<int> vLayer;
        while (index1 < deq.size()|| index2 < deq.size())
        {
            auto cur =  deq[index2];
            if (cur == nullptr)//翻转打印方向
            {
                if(forwardPrintf)
                    ret.push_back(vLayer);
                else
                {
                    int temp = index2 - 1;
                    while (index1 - 1 < temp)
                    {
                        vLayer.push_back(deq[temp]->val);
                        temp--; 
                    }
                    ret.push_back(vLayer);
                }
                
                vLayer.clear();
                index1 = index2;
                index1++;
                index2++;
                forwardPrintf = !forwardPrintf;
            }
            else if (forwardPrintf)//直接打印
            {
                vLayer.push_back( cur->val);
                index1++;
                index2++;
            }
            else//index2先行
            {
                index2++;
            }
        }
    }
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> ret;
        if (root == nullptr) 
            return ret;

        deque<TreeNode*> deq;
        deq.push_back(root);
        deq.push_back(nullptr);

        int index = 0;
        BFS(deq, index);

        
        toVector(deq,ret);
        return ret;
    }
};

BFS遍历时输出

思路：
既然使用双端队列，那就可以直接在队首或者队尾进行增删。
正向打印时，遍历deque中从front开始的所有节点，将其左右子树按序放入队尾push_back；
当正向打印到达deque的第一个nullptr时，保存这之前遍历的元素，改变当前节点至队尾元素，改变遍历方向。
当反向打印时，遍历deque中end()–的元素，将其左右子树反序放入deque的首部push_front;
当反向打印到达deque的第一个nullptr时，保存这之前遍历的元素，pop当前nullptr，使当前节点成为deque的队首元素。

执行用时：4 ms
内存消耗：11.3 MB

/**
 * 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:
    void BfsPro(deque<TreeNode*>& deq,bool bForword,vector<vector<int>>& ret)
    {
        vector<int> layer;
        auto cur = deq.front();
        while (deq.size())
        {
            if (bForword && cur == nullptr)
            {
                ret.push_back(layer);
                layer.clear();

                auto tmp = deq.end();
                tmp--;
                cur = *tmp;
                if (deq.size() == 1 && cur == nullptr)
                    break;

                
                bForword = !bForword;
            }
            else if (!bForword && cur == nullptr)
            {
                ret.push_back(layer);
                layer.clear();

                cur = deq.front();
                if (deq.size() == 1 && cur == nullptr)
                    break;

                bForword = !bForword;
            }
            else if (bForword && cur != nullptr)
            {
                layer.push_back(cur->val);
                if (cur->left) deq.push_back(cur->left);
                if (cur->right) deq.push_back(cur->right);
                deq.pop_front();
                cur = deq.front();
            }
            else if (!bForword && cur != nullptr)
            {
                layer.push_back(cur->val);
                if (cur->right) deq.push_front(cur->right);
                if (cur->left) deq.push_front(cur->left);
                
                deq.pop_back();
                auto tmp = deq.end();
                tmp--;
                cur = *(tmp);
            }
        }
    }
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> ret;
        if(root== nullptr)
            return ret;

        deque<TreeNode*> deq;
        deq.push_back(root);
        deq.push_back(nullptr);
        bool bForword = true;

        BfsPro(deq, bForword,ret);
        return ret;
    }
};

DFS

深度优先遍历

如果当前节点的双端队列不存在，则创建一个双端队列，并将该节点加入队列中。
如果当前节点的双端队列已经存在，则直接插入该队列中。
都递归当前节点的左右子节点。

输出时，需要根据层数，改变输出方向。

/**
 * 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:
   void Dfs(TreeNode* root, deque<deque<int>>& deq,int layer)
    {

        if (root == nullptr)
            return;

        if (layer < deq.size())
        {
            deq[layer].push_back(root->val);
        }
        else
        {
            deque<int> tmp;
            tmp.push_back(root->val);
            deq.push_back(tmp);
        }

        Dfs(root->left,deq, layer+1);
        Dfs(root->right, deq,  layer+1);

    }
    void dePrint(deque<deque<int>>& deq,vector<vector<int>>& ret)
    {
        vector<int> layer;
        for (int i = 0; i < deq.size(); ++i)
        {
            if (i % 2 == 0)
            {
                while (deq[i].size())
                {
                    layer.push_back(deq[i][0]);
                    deq[i].pop_front();
                }
            }
            else
            {
                while (deq[i].size())
                {
                    auto tmp = deq[i].end();
                    tmp--;
                    layer.push_back(*(tmp));
                    deq[i].pop_back();
                }
            }
            ret.push_back(layer);
            layer.clear();
        }
    }
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> ret;
        if(root== nullptr)
            return ret;

        deque<deque<int>> deq;
        Dfs( root,  deq, 0);
        
        dePrint( deq,ret);
        return ret;
    }
};

由于深度优先遍历时，无法输出结果，所以相比较而言，还是广度优先遍历的方法更优。