32、从上到下打印二叉树（层序遍历）

题目

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

题目二：分行从上到下打印二叉树（每一层打印到一行）

题目三：之字形打印二叉树（第一行从左到右，第二行从右到左，......）

思路

二叉树的层序遍历本质上就是广度优先搜索（BFS），题目二、三无非就是输出格式上添加一些细节限制。

广度优先搜索的基本套路：无论遍历一幅有向图还是一棵树，都要用到队列。

        首先把起始节点（对树而言是根节点）放入队列。

        接下来每次从队列的头部取出一个节点，遍历这个节点之后把它能到达的节点（对树而言是子节点）都依次放入队列。

        重复这个遍历过程，直到队列中的节点全部被遍历为止。

 

题目二要求每一层打印到一行，就是要想办法直到每一层节点的个数，循环开始前求队列长度（初始为1），即当前这一层节点的个数，控制打印这么多个节点，并入队子节点后，再重复循环上述。（也可剑指offer思路，设置两个变量，toBeprinted表示在当前节点还没打印的节点数（出队减1）；nextLevel表示下一层的节点数。（入队加1）。当toBeprinted为0时换行。）

题目三先从左到右，后从右到左......其实在题二的基础上，添加判断该行是否需要反序（偶数行反序），借助库函数reverse()也可，可能效率不高。这里通过分析打印顺序，借助两个栈，如果打印的是奇数行，下一层节点先左节点后右节点保存到第一个栈中，如果打印的是偶数行，下一层节点先右节点后左节点保存到第二个栈中。循环直到两个栈为空。

C++代码实现

   /********分行打印二叉树*********************/
     vector<vector<int> > Print(TreeNode* pRoot) {
            vector<vector<int> > res;
            if(pRoot == NULL)
                return res;
            queue<TreeNode*> q;
            q.push(pRoot);
            while(!q.empty())
            {
                int len = q.size();
                vector<int> vec;
                TreeNode* front;
                for(int i = 0; i<len; i++)
                {
                    front = q.front();
                    vec.push_back(front->val);
                    q.pop();
                    if(front->left)
                        q.push(front->left);
                    if(front->right)
                        q.push(front->right);
                }
                res.push_back(vec);
            }
            return res;
        
        }
/************之字形打印二叉树*****************/
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int> > res;
        if(pRoot == NULL)
            return res;
        stack<TreeNode*> s1,s2;
        s2.push(pRoot);
        while(!s1.empty() || !s2.empty())
        {
            if(!s2.empty())
            {
                vector<int> vec1;//奇数层
                while(!s2.empty())
                {

                    TreeNode* s2top = s2.top();
                    vec1.push_back(s2top->val);
                    if(s2top->left != NULL)
                        s1.push(s2top->left);
                    if(s2top->right != NULL)
                        s1.push(s2top->right);
                    s2.pop();
                }
                res.push_back(vec1);
            }
            if(!s1.empty())
            {
                vector<int> vec2;//偶数层
                while(!s1.empty())
                {

                    TreeNode* s1top = s1.top();
                    vec2.push_back(s1top->val);
                    if(s1top->right != NULL)
                        s2.push(s1top->right);
                    if(s1top->left != NULL)
                        s2.push(s1top->left);
                    s1.pop();

                }
                res.push_back(vec2);
             }
        }
        return res;
    }