剑指Offer--023-从上往下打印二叉树（层次遍历二叉树）

链接

---

牛客OJ：从上往下打印二叉树

九度OJ：http://ac.jobdu.com/problem.php?pid=1523

GitHub代码： 023-从上往下打印二叉树

CSDN题解：剑指Offer–023-从上往下打印二叉树

牛客OJ	九度OJ	CSDN题解	GitHub代码
从上往下打印二叉树	1523-从上往下打印二叉树	剑指Offer–023-从上往下打印二叉树	023-从上往下打印二叉树

题意

---

题目描述

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

分析

---

其实就是层次遍历，这个我们在我之前的一篇博客里面将的很清楚了

二叉树的遍历详解（前序中序后序层次-递归和非递归）

其中调试的时候使用了

剑指Offer–006-重构二叉树来辅助我们通过前序和中序遍历的序列来生成二叉树

直接贴代码，只需要直接将我们层次遍历输出过程，变成将输入压入vector中即可

#include <iostream>
#include <vector>
#include <deque>
#include <queue>

using namespace std;

//  调试开关
#define __tmain main

#ifdef __tmain

#define debug cout

#else

#define debug 0 && cout

#endif // __tmain


#define undebug 0 && cout


#ifdef __tmain
struct TreeNode
{
    int val;
    struct TreeNode *left;
    struct TreeNode *right;

    TreeNode(int x)
    :val(x), left(NULL), right(NULL)
    {
    }
};
#endif // __tmain



class Solution
{
    vector<int> res;
public:
    vector<int> PrintFromTopToBottom(TreeNode *root)
    {
        ///  方法1  -=>  循环调用递归打印每一层
        LevelOrder(root);

        ///  方法2  -=>  使用两个双端队列
        LevelOrderDev(root);

        ///  方法3  -=>  使用双指针标识当前指针和结束
        LevelOrderUsePoint(root);

        ///  方法4  -=>  使用aprent和childzsizesize标识前一层和当前层的节点个数
        LevelOrderUseSize(root);

        ///  方法4  -=>  在队列中插入结束标识来标识当前层结束
        LevelOrderUseEnd(root);
        return this->res;
    }

    /// 打印某一层的节点，递归实现
    int PrintLevel(TreeNode *root, int level)
    {
        if(root == NULL || level < 0)
        {
            return 0;
        }
        else if(level == 0)
        {
            debug <<root->val;
            res.push_back(root->val);        /// add for result in vector

            return 1;
        }
        else
        {
            return PrintLevel(root->left, level - 1) + PrintLevel(root->right, level - 1);
        }
    }

    ///  循环每层输出其节点，调用递归函数
    void LevelOrder(TreeNode *root)
    {
        res.clear( );           /// add for result in vector
        if(root == NULL)
        {
            return;
        }
        for(int level = 0; ; level++)
        {
            if(PrintLevel(root, level) == 0)
            {
                break;
            }
            debug <<endl;
        }
    }

    //
    ///  使用两个双端队列
    //
    void LevelOrderDev(TreeNode *root)
    {
        res.clear( );           /// add for result in vector

        /// deque双端队列，
        /// 支持迭代器，有push_back()方法，
        /// 跟vector差不多，比vector多了个pop_front,push_front方法

        deque<TreeNode *> qFirst, qSecond;
        qFirst.push_back(root);

        while(qFirst.empty( ) != true)
        {
            while (qFirst.empty( ) != true)
            {
                TreeNode *temp = qFirst.front( );
                qFirst.pop_front( );

                debug << temp->val;
                res.push_back(temp->val);        /// add for result in vector


                if (temp->left != NULL)
                {
                    qSecond.push_back(temp->left);
                }
                if (temp->right != NULL)
                {
                    qSecond.push_back(temp->right);
                }
            }
            debug << endl;
            qFirst.swap(qSecond);

        }
    }


    //
    ///  使用双指针标识当前指针和结束
    //
    void LevelOrderUsePoint(TreeNode *root)
    {
        res.clear( );           /// add for result in vector

        vector<TreeNode*> vec;
        vec.push_back(root);

        int cur = 0;
        int end = 1;

        while (cur < vec.size())
        {
            end = vec.size();       ///  新的一行访问开始，重新定位end于当前行最后一个节点的下一个位置

            while (cur < end)
            {
                debug << vec[cur]->val;  ///  访问节点
                res.push_back(vec[cur]->val);        /// add for result in vector

                if (vec[cur]->left != NULL) ///  压入左节点
                {
                    vec.push_back(vec[cur]->left);

                }
                if (vec[cur]->right != NULL)    ///  压入右节点
                {
                    vec.push_back(vec[cur]->right);
                }
                cur++;
            }
            debug << endl;
        }
    }


    //
    ///  使用aprent和childzsizesize标识前一层和当前层的节点个数
    //
    void LevelOrderUseSize(TreeNode *root)
    {
        res.clear( );           /// add for result in vector

        int parentSize = 1, childSize = 0;
        TreeNode *temp = NULL;

        queue<TreeNode *> q;
        q.push(root);
        while(q.empty( ) != true)
        {
            temp = q.front( );
            debug <<temp->val;
            res.push_back(temp->val);        /// add for result in vector

            q.pop( );

            if (temp->left != NULL)
            {
                q.push(temp->left);

                childSize++;
            }
            if (temp->right != NULL)
            {
                q.push(temp->right);
                childSize++;
            }

            parentSize--;
            if (parentSize == 0)
            {
                parentSize = childSize;
                childSize = 0;
                debug << endl;
            }

        }
    }

    //
    ///  在队列中插入结束标识来标识当前层结束
    //
    void LevelOrderUseEnd(TreeNode *root)
    {
        res.clear( );           /// add for result in vector

        queue<TreeNode *> q;

        q.push(root);
        q.push(NULL);

        while(q.empty( ) != true)
        {
            TreeNode* node = q.front();
            q.pop();

            if (node)
            {
                debug << node->val;
                res.push_back(node->val);        /// add for result in vector

                if (node->left != NULL)
                {
                    q.push(node->left);
                }
                if (node->right != NULL)
                {
                    q.push(node->right);
                }
            }
            else if (q.empty( ) != true)
            {
                q.push(NULL);
                debug << endl;
            }
        }
    }


    struct TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> in)
    {
        //  前序遍历的长度跟中序遍历的长度应该相同
        if(pre.size( ) != in.size( ))
        {
            undebug <<"the length of PRE and IN should be smae" <<endl;
            return NULL;
        }

        // 长度不能为0
        int size = pre.size( );
        if(size == 0)
        {
            undebug <<"it's a NULL tree(length = 0)" <<endl;
            return NULL;
        }

        int length = pre.size( );
        undebug <<"the length of your tree = " <<length <<endl;
        int value = pre[0];      //  前序遍历的第一个结点是根节点
        TreeNode *root = new TreeNode(value);

        undebug <<"the root is" <<root->val <<endl;
        //  在中序遍历中查找到根的位置
        int rootIndex = 0;
        for(rootIndex = 0; rootIndex < length; rootIndex++)
        {
            if(in[rootIndex] == value)
            {
                undebug <<"find the root at " <<rootIndex <<" in IN" <<endl;
                break;
            }
        }
        if(rootIndex >= length)
        {
            undebug <<"can't find root (value = " <<value <<") in IN" <<endl;
            return NULL;
        }

        ///  区分左子树和右子树
        ///  中序遍历中, 根左边的就是左子数, 右边的就是右子树
        ///  前序遍历中, 根后面是先遍历左子树, 然后是右子树

        ///  首先确定左右子树的长度, 从中序遍历in中确定
        int leftLength = rootIndex;
        int rightLength = length - 1 - rootIndex;
        undebug <<"left length = " <<leftLength <<", rightLength = " <<rightLength <<endl;
        vector<int> preLeft(leftLength), inLeft(leftLength);
        vector<int> preRight(rightLength), inRight(rightLength);
        for(int i = 0; i < length; i++)
        {
            if(i < rootIndex)
            {
                //  前序遍历的第一个是根节点, 根后面的(leftLegnth = rootIndex) - 1个节点是左子树, 因此是i+1
                preLeft[i] = pre[i + 1];
                //  中序遍历前(leftLength = rootIndex) - 1个节点是左子树, 第rootIndex个节点是根
                inLeft[i] = in[i];
                undebug <<preLeft[i] <<inLeft[i] <<" ";

            }
            else if(i > rootIndex)
            {
                //  前序遍历的第一个是根节点, 根后面的(leftLegnth = rootIndex) - 1个节点是左子树, 后面是右子树
                preRight[i - rootIndex - 1] = pre[i];
                //  中序遍历前(leftLength = rootIndex) - 1个节点是左子树, 第rootIndex个节点是根, 然后是右子树
                inRight[i - rootIndex - 1] = in[i];
                undebug <<preRight[i - rootIndex - 1] <<inRight[i - rootIndex - 1] <<" ";

            }
        }
        undebug <<endl <<"the left tree" <<endl;
        for(int i = 0; i < leftLength; i++)
        {
            undebug <<preLeft[i] <<inLeft[i] <<" ";
        }
        undebug <<endl;
        undebug <<"the right tree" <<endl;
        for(int i = 0; i < rightLength; i++)
        {
            undebug <<preRight[i] <<inRight[i] <<" ";
        }
        undebug <<endl;


        root->left = reConstructBinaryTree(preLeft, inLeft);
        root->right = reConstructBinaryTree(preRight, inRight);

        return root;
    }



};

int __tmain( )
{
    int pre[] = { 1, 2, 4, 7, 3, 5, 6, 8 };
    int in[] = { 4, 7, 2, 1, 5, 3, 8, 6 };

    vector<int> preOrder(pre, pre + 8);
    vector<int>  inOrder( in,  in + 8);

    Solution solu;
    TreeNode *root = solu.reConstructBinaryTree(preOrder, inOrder);
    solu.PrintFromTopToBottom(root);

    return 0;
}