剑指offer之按之字形顺序打印二叉树

题目描述

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

解题思路

所谓“之字形”打印，第一行是从左到右打印，第二行是从右到左打印，第三行又是从左到右打印….
即，奇数行(根为第一行)是从左到右打印，而偶数行是从右到左打印。

方法一：栈（推荐）

每行的节点的访问顺序是相反的，我们可以用两个栈来隔行存储，一个栈保存奇数行的结点，根据“左结点->右结点”的顺序将结点push进另一个栈中；而另一个栈保存偶数行的结点，根据“右子树->左子树”的顺序将结点push进另一个栈中，直到两个栈都为空。

复杂度分析：
由于每个结点都会入栈一次，然后出栈打印。故时间复杂度为O(N)
代码中使用了两个辅助栈，分别用来保存奇数行的结点和偶数行的结点。故空间复杂度也是O(N)

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int> > result;
        if(pRoot == NULL)
            return result;
        stack<TreeNode *> stack1,stack2; //stack1表示保存奇数行的栈，stack2表示保存偶数行的栈
        if(pRoot!=NULL)
            stack1.push(pRoot);
        struct TreeNode *node;
        while(!stack1.empty() || !stack2.empty()){
            vector<int> data;
            if(!stack1.empty()){
                while(!stack1.empty()){
                    node = stack1.top();
                    stack1.pop();
                    data.push_back(node->val);
                    if(node->left!=NULL) //先左后右
                        stack2.push(node->left);
                    if(node->right!=NULL)
                        stack2.push(node->right);
                }
                result.push_back(data);
            }
            else if(!stack2.empty()){
                while(!stack2.empty()){
                    node = stack2.top();
                    stack2.pop();
                    data.push_back(node->val);
                    if(node->right!=NULL) //先右后左
                        stack1.push(node->right);
                    if(node->left!=NULL)
                        stack1.push(node->left);
                }
                result.push_back(data);
            }
        }
        return result;
    }
};

方法二：层次遍历+Reserve

用队列实现层次遍历，再加上判断奇偶改变方向就行，奇数层就直接按层次遍历从左到右输出，偶数层用到了reverse函数来将偶数层的数据反转，reverse方法虽然方便但是比较耗时，因为此方法不是面试时推荐的最优解法。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int>> res;
        if(pRoot == NULL)
            return res;
        queue<TreeNode*> que;
        que.push(pRoot);
        bool even = false; //偶数层
        while(!que.empty()){
            vector<int> vec;
            const int size = que.size();
            for(int i=0; i<size; ++i){
                TreeNode* tmp = que.front();
                que.pop();
                vec.push_back(tmp->val);
                if(tmp->left != NULL)
                    que.push(tmp->left);
                if(tmp->right != NULL)
                    que.push(tmp->right);
            }
            if(even)
                std::reverse(vec.begin(), vec.end()); //偶数层反转数据
            res.push_back(vec);
            even = !even;
        }
        return res;
    }
};