加qq1126137994 微信liu1126137994 一起学习更多技术

1、原理：

层序遍历所要解决的问题很好理解，就是按二叉树从上到下，从左到右依次打印每个节点中存储的数据。如下图：

　　按层序遍历的原则，打印顺序依次应该是：A->B->C->D->E->F->G。
　　看完是不是感触非常深，这不就是队列数据结构最拿手的绝活吗，FIFO，先进先出！我从上到下，从左到右依次将每个数放入到队列中，然后按顺序依次打印就是想要的结果。
　　实现方案的确很好想到，但是具体实现容易卡壳在你是将什么放入队列中。本人当时面试仅存储每个数据到队列中，造成访问完A，然后将B和C（左右孩子）放入队列，并且删除最前面一个数（当前也就是A），这样B就轮到了最前方。想着是依次下去，但是如果队列仅存数据就会发现，不知道后面如何顺序访问下去，也不知道二叉树何时停止。所以正确的方式是队列中每个节点应该是存储一个二叉树的指针，这样才能依次依靠指针left和right访问下去。
　　原理还是挺简单的，笔者认为除了上面需要主要其他都挺好理解的，下面直接看C++程序以及程序中注解吧。

2、C++程序实现

#include<cstdio>
#include<queue>
using namespace std;
/*二叉树结构体，并且构建了有参构造函数*/
struct BinaryTree{
    int vec;
    BinaryTree* left;
    BinaryTree* right;
    BinaryTree(int data)
        :vec(data), left(nullptr), right(nullptr){ 
    }
};
/*队列实现层序遍历*/
void printTree(BinaryTree* arr[])
{
    queue<BinaryTree*> rel; //定义一个队列，数据类型是二叉树指针，不要仅是int！！不然无法遍历
    rel.push(arr[0]);
    while (!rel.empty())
    {
        BinaryTree* front = rel.front();
        printf("%d\n", front->vec);
        rel.pop();                  //删除最前面的节点
        if (front->left != nullptr) //判断最前面的左节点是否为空，不是则放入队列
            rel.push(front->left);  
        if (front->right != nullptr)//判断最前面的右节点是否为空，不是则放入队列
            rel.push(front->right);
    }
}
int main(){
    /*构建二叉树*/
    BinaryTree* s_arr[6];
    s_arr[0] = new BinaryTree(0);
    s_arr[1] = new BinaryTree(1);
    s_arr[2] = new BinaryTree(2);
    s_arr[3] = new BinaryTree(3);
    s_arr[4] = new BinaryTree(4);
    s_arr[5] = new BinaryTree(5);
    s_arr[0]->left = s_arr[1];  // 0
    s_arr[0]->right = s_arr[2]; // 1 2
    s_arr[1]->left = s_arr[3];  // 3 5
    s_arr[3]->left = s_arr[4];  //4
    s_arr[2]->right = s_arr[5]; //所以层序遍历的结果为：0 1 2 3 5 4
    /*层次遍历打印所有节点*/
    printTree(s_arr);
    /*释放所有空间*/
    for (int i = 0; i < 6; i++)
        delete s_arr[i];
    return 0;
}

有一棵二叉树，请设计一个算法，按照层次打印这棵二叉树。

给定二叉树的根结点root，请返回打印结果，结果按照每一层一个数组进行储存，所有数组的顺序按照层数从上往下，且每一层的数组内元素按照从左往右排列。保证结点数小于等于500。

/* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/

class TreePrinter {
public:
    vector<vector<int> > printTree(TreeNode* root) {
        // write code here
        queue<TreeNode*> rel;
        vector<vector<int> > que;
        if(root==nullptr)
            return que;
        rel.push(root);
        while(!rel.empty())
        {
            vector<int> row;
            int size=rel.size();
            for(int i=0;i<size;i++)
            {
                TreeNode* front=rel.front();
               rel.pop();
                row.push_back(front->val);

                if(front->left!=nullptr)
                    rel.push(front->left);
                if(front->right!=nullptr)
                    rel.push(front->right);
            }
            que.push_back(row);

        }

        return que;
    }
};

或者：

/* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/

class TreePrinter {
public:
    vector<vector<int> > printTree(TreeNode* root) {
        // write code here

        vector<vector<int>> que;
        if(root==nullptr)
            return que;
        TreeNode* last=root;
        TreeNode* nlast=nullptr;
        vector<int> row;
        queue<TreeNode*> rel;
        rel.push(root);
        while(!rel.empty())
        {
            TreeNode* front = rel.front();
            rel.pop();
            if(front->left!=nullptr)
            {
                nlast=front->left;
                rel.push(front->left);
            }
            if(front->right!=nullptr)
            {
                nlast=front->right;
                rel.push(front->right);
            }
            row.push_back(front->val);
            if(front==last)
            {
                last=nlast;
                que.push_back(row);
                row.clear();
            }
        }
        return que;
    }
};