剑指offer之之字形打印二叉树

1.问题描述

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

2.分析

前面讲述了分行分成打印二叉树，这里要之字形。
例子：

//                8
//        4              12
//     2     6       10      14
//   1  3  5  7     9 11   13  15

打印结果应该是：

8
12 4
2 6 10 14
15 13 11 9 7 5 3 1

• 打印第0层，结果是8，一个元素，没有什么问题。
• 打印第1层，结果是12 4，这里就有问题了，第一层我们保存的时候，应该是4 12，看来顺序反了，我们是不是应该使用栈。
• 打印第二层，结果是2 6 10 14，前面一层访问顺序是12 4，我们保存第二层的时候，应该是14 10 6
  2。这里有一个问题，我们访问节点12的时候，应该是先访问右节点，之后才是左节点。访问节点4也是一样。
• 访问第三层的时候，和访问第一层方法和顺序是一样的。

所以，我们要注意节点的奇偶性，需要使用两个栈来分别保存当前层的节点和下一层的节点。

3.源代码：

vector<vector<int> > Print(TreeNode* pRoot)
{
    vector<vector<int> > results;
    if(pRoot == NULL)
        return results;
    //栈1pop()是从左到右的值
    stack<TreeNode*> stack1;
    //栈2pop()是从右到左的值
    stack<TreeNode*> stack2;

    stack1.push(pRoot);
    //如果两个栈都为空，那么表示已经遍历完了二叉树
    while(!stack1.empty() || !stack2.empty())
    {
        //把栈1中的元素都pop()到vector中，并且把节点的左,右节点push到栈2中
        if(!stack1.empty())
        {
            vector<int> res;
            while(!stack1.empty())
            {
                TreeNode* pNode = stack1.top();
                stack1.pop();

                res.push_back(pNode->val);

                if(pNode->left != NULL)
                    stack2.push(pNode->left);
                if(pNode->right != NULL)
                    stack2.push(pNode->right);
            }
            results.push_back(res);
        }
        //把栈2中的元素都pop()到vector中，并且把节点的右,左节点push到栈1中
        else if(!stack2.empty())
        {
            vector<int> res;
            while(!stack2.empty())
            {
                TreeNode* pNode = stack2.top();
                stack2.pop();

                res.push_back(pNode->val);

                if(pNode->right != NULL)
                    stack1.push(pNode->right);
                if(pNode->left != NULL)
                    stack1.push(pNode->left);
            }
            results.push_back(res);
        }
    }
    return results;
}

4.结论

之字形遍历是挺复杂的，我们需要举一个例子，具体分析，我们才又可以找到方法和规律。比如找到需要两个栈，找到两个栈需要相互交换