从上到下打印二叉树-之字形打印二叉树

面试题32：从上往下打印出二叉树的每个节点，同层节点从左至右打印。

/**
 * 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> res;
        if (root == nullptr) {
            return res;
        }

        queue<TreeNode*> q; // 核心数据
        
        q.push(root); // 将起点加入队列

        while (!q.empty()) {
            int sz = q.size();
            // 将当前队列中所有节点向四周扩散
            for (int i = 0; i < sz; ++i) {
                TreeNode* curr = q.front();
                q.pop();

                // 这里判断是否到达终点，本题无需操作
                res.push_back(curr->val);

                // 将curr相邻节点入队
                if (curr->left) {
                    q.push(curr->left);
                }
                if (curr->right) {
                    q.push(curr->right);
                }
            }
        }
        return res;
    }
};

如何广度遍历一副有向图？同样也可以基于队列实现。树是图的一种特殊退化形式，从上到下按层次遍历二叉树，从本质上来说就是广度优先遍历二叉树。

题目二：分行从上到下打印二叉树

/**
 * 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<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res; // 相当于bfs框架中的step
        if (root == nullptr) {
            return res;
        }

        queue<TreeNode*> q; // 核心数据
        
        q.push(root); // 将起点加入队列

        while (!q.empty()) {
            int sz = q.size();
            vector<int> level; // 存放每一层的节点
            // 将当前队列中所有节点向四周扩散
            for (int i = 0; i < sz; ++i) {
                TreeNode* curr = q.front();
                q.pop();

                // 这里判断是否到达终点，本题无需操作
                level.push_back(curr->val);

                // 将curr相邻节点入队
                if (curr->left) {
                    q.push(curr->left);
                }
                if (curr->right) {
                    q.push(curr->right);
                }
            }
            // 每一层遍历完成后更新res;
            res.push_back(level);
        }
        return res;
    }
};

题目三：之字形打印二叉树。

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

方法一：deque + bfs

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
// 初始层从0层开始，即奇数层要反着遍历，从尾部压入从尾部取出，从头部压入从头部取出，模拟栈，先进后出
// 当为偶数层时，【尾部取出】，子节点（奇数层的节点）由左向右（从头部压入队列）
// 当为奇数层时，（从头部取出节点），子节点（偶数层的节点）由右向左【从尾部压入队列】
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int> > ans;
        if (root == nullptr) return ans;

        deque<TreeNode*> dq; // 核心数据
        // 第0层为偶数层，虚设上层为奇数层，奇数层的子节点从尾部压入,因此偶数层节点尾部取出（从尾部入从尾部出，模拟栈行为）
        dq.push_back(root);
        int layer = 0; // root层为第0层，偶数层

        while (!dq.empty()) {
            int sz = dq.size();
            vector<int> level;
            if (layer & 1) { // 奇数层
                // 当前层节点向四周扩散
                for (int i = 0; i < sz; i++) {
                    TreeNode* cur = dq.front();  dq.pop_front(); // 奇数层从头部取出

                    // 针对当前节点的操作
                    level.push_back(cur->val);

                    // cur节点的相邻节点由右往左加入队尾(栈)中
                    if (cur->right) dq.push_back(cur->right);
                    if (cur->left) dq.push_back(cur->left);
                }
            } else { // 偶数层
                // 当前层节点向四周扩散
                for (int i = 0; i < sz; i++) {
                    TreeNode* cur = dq.back();  dq.pop_back(); // 偶数层从尾部取出

                    // 针对当前节点的操作
                    level.push_back(cur->val);

                    // cur节点的相邻节点由左往右加入队头(栈)中
                    if (cur->left) dq.push_front(cur->left);
                    if (cur->right) dq.push_front(cur->right);
                }
            }
            layer++;
            ans.push_back(level);
        }
        return ans;
    }
};

方法二：两个栈 + bfs

思路：
设两个栈，s1存放奇数层，s2存放偶数层
遍历s1节点的同时按照左子树、右子树的顺序加入s2，
遍历s2节点的同时按照右子树、左子树的顺序加入s1

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
//设两个栈，s1存放奇数层，s2存放偶数层
//遍历s1节点的同时按照左子树、右子树的顺序加入s2，
//遍历s2节点的同时按照右子树、左子树的顺序加入s1
class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
       
        vector<vector<int> >  Vprint;    //所有待打印的数据容器
        if(pRoot == nullptr)
            return Vprint;
        stack<TreeNode*> s1, s2;    //栈里面存放的是指向该节点的指针
        vector<int> Vrow;    //行容器，存放的是该节点的数据域
        
        s1.push(pRoot);
        while(!s1.empty() || !s2.empty()){
            
            //1.从s1出发，弹出s1栈顶元素，弹出前将其子节点(从左向右)压入s2
            while(!s1.empty()){
                TreeNode* pNode = s1.top();
                Vrow.push_back(pNode->val);    //出栈前将栈顶元素放进Vrow容器中
                if(pNode->left) 
                    s2.push(pNode->left);
                if(pNode->right) 
                    s2.push(pNode->right);
                s1.pop();    //左右子节点压入到栈s2后，s1栈顶元素出栈
            }
            if(!Vrow.empty()){
                Vprint.push_back(Vrow);
                Vrow.clear();    //清空Vrow中元素
            }
            
            //2.从s2出发，弹出s2栈顶元素，弹出前将其子节点(从右向左)压入s1
            while(!s2.empty()){
                TreeNode* pNode = s2.top();
                Vrow.push_back(pNode->val);
                if(pNode->right) 
                    s1.push(pNode->right);
                if(pNode->left) 
                    s1.push(pNode->left);
                s2.pop();
            }
            if(!Vrow.empty()){
                Vprint.push_back(Vrow);
                Vrow.clear();
            }
        }
        return Vprint;
    }
};

方法三：BFS+双端队列（同方法一）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

// 初始层从0层开始，即奇数层要反着遍历
// 当为偶数层时，子节点从尾部压入，先压入左节点，后压入右节点。并从头部取出，
// 当为奇数层是，子节点从头部压入，先压入右节点，后压入左节点。并从尾部取出

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        if (root == nullptr) return ans;

        deque<TreeNode*> dq;

        dq.push_back(root);
        int layer = 0;

        while (!dq.empty()) {
            auto sz = dq.size(); // 队列中存储每一层的节点
            vector<int> res; // 保存每一层的节点
            /* 将当前队列中的所有节点向四周扩散 */
            for (int i = 0; i < sz; i++) { // 一次while循环将每一层节点处理完
                TreeNode* cur;
                if (layer & 1) { // 奇数层,子节点从头部压入，先压入右节点，后压入左节点。并从尾部取出
                    cur = dq.back(); dq.pop_back();

                    res.push_back(cur -> val);   

                    if (cur -> right) dq.push_front(cur -> right);
                    if (cur -> left) dq.push_front(cur -> left);          
                } else { // 偶数层，子节点从尾部压入，先压入左节点，后压入右节点。并从头部取出
                    cur = dq.front(); dq.pop_front();

                    res.push_back(cur -> val);

                    if (cur -> left) dq.push_back(cur -> left);
                    if (cur -> right) dq.push_back(cur -> right);
                }
            }
            ++layer;
            ans.push_back(res);
        }
        return ans;
    }
};