二叉树层次遍历

《编程之美》3.10介绍了二叉树层次遍历及从左到右输出每一层，并给出了两个扩展题目。下面是完整的代码实现：

#include <iostream>
#include <cassert>
#include <string>
#include <fstream>
#include <vector>
#include <queue>
using namespace std;

struct Node
{
    int m_data;
    Node* m_lChild;
    Node* m_rChild;
    Node(int data=0,Node* lChild=NULL,Node* rChild=NULL)
        :m_data(data),m_lChild(lChild),m_rChild(rChild){}
};

//方法一通过返回值来改变和构造整棵树
//Node* CreateTree(Node* pNode,vector<int>::iterator &begin,vector<int>::iterator end)
//{
//    if (*begin!=-1)
//    {
//        pNode=new Node(*begin);
//        if (pNode)
//        {
//            if (++begin!=end)
//            {
//                pNode->m_lChild=CreateTree(pNode->m_lChild,begin,end);
//            }
//            if (++begin!=end)
//            {
//                pNode->m_rChild=CreateTree(pNode->m_rChild,begin,end);
//            }
//        }
//    }
//    return pNode;
//}

//方法二不需要返回值来构造一棵树，传递指针的地址来改变指针的指向
//这种方法可以修改为：传递指针的引用来改变指针的指向:
//void CreateTree(Node* &pNode,vector<int>::iterator &begin,vector<int>::iterator end)
void CreateTree(Node** pNode,vector<int>::iterator &begin,vector<int>::iterator end)
{
    if (*begin!=-1)
    {
        *pNode=new Node(*begin);
        if (*pNode)
        {
            if (++begin!=end)
            {
                CreateTree(&((*pNode)->m_lChild),begin,end);
            }
            if (++begin!=end)
            {
                CreateTree(&((*pNode)->m_rChild),begin,end);
            }
        }
    }
}

Node* CreateTree(const char* fileName)
{
    ifstream inFile;
    inFile.open(fileName);
    int value;
    vector<int> vec;
    while (inFile>>value)
    {
        vec.push_back(value);
    }
    if (vec.empty())
    {
        return NULL;
    }
    Node* pRoot=NULL;
    //pRoot=CreateTree(pRoot,vec.begin(),vec.end());
    CreateTree(&pRoot,vec.begin(),vec.end());
    return pRoot;
}


void InOrderTra(Node* pRoot)
{
    if (pRoot)
    {
        InOrderTra(pRoot->m_lChild);
        cout<<pRoot->m_data<<"  ";
        InOrderTra(pRoot->m_rChild);
    }
}

//打印二叉树中某层次的节点，从左到右
//根节点为第0层
//成功返回1，失败返回0
int PrintNodeAtLevel(Node* root,int level)
{
    if (!root || level<0)
    {
        return 0;
    }
    if (level==0)
    {
        cout<<root->m_data<<"  ";
        return 1;
    }
    return PrintNodeAtLevel(root->m_lChild,level-1) | PrintNodeAtLevel(root->m_rChild,level-1);
}

//求二叉树的深度
int Depth(Node* root)
{
    if (!root)
    {
        return 0;
    }
    return 1+(max(Depth(root->m_lChild),Depth(root->m_rChild)));
}

//利用二叉树的深度及打印二叉树的某层次的节点来
//层次遍历二叉树
void LevelTra1(Node* root)
{
    if (!root)
    {
        return;
    }
    int depth=Depth(root);
    for (int i=0;i<depth;i++)
    {
        PrintNodeAtLevel(root,i);
        cout<<endl;
    }
}

//当不知道二叉树的深度时，利用PrintNodeAtLevel的返回值
//来结束循环
void LevelTra2(Node* root)
{
    if (!root)
    {
        return;
    }
    int depth=Depth(root);
    for (int i=0;;i++)
    {
        if (!PrintNodeAtLevel(root,i))
        {
            break;
        }
        cout<<endl;
    }
}

//非递归，利用queue记录节点信息来层次
//遍历二叉树。但是这种做法，怎样才能做
//到访问每层之后打印一个换行呢？
void LevelTra3(Node* root)
{
    if (!root)
    {
        return;
    }
    queue<Node*> m_queue;
    m_queue.push(root);
    while (!m_queue.empty())
    {
        Node* cur=m_queue.front();
        cout<<cur->m_data<<"  ";
        m_queue.pop();
        if (cur->m_lChild)
        {
            m_queue.push(cur->m_lChild);
        }
        if (cur->m_rChild)
        {
            m_queue.push(cur->m_rChild);
        }
    }
    cout<<endl;
}

//编程之美上的方法：cur和last
//两个下标太巧妙了！！！
void LevelTra4(Node* root)
{
    if (!root)
    {
        return;
    }
    vector<Node*> vec;
    vec.push_back(root);
    int cur=0;
    int last=1;
    while (cur<vec.size())
    {
        last=vec.size();
        while (cur<last)
        {
            cout<<vec[cur]->m_data<<"  ";
            if (vec[cur]->m_lChild)
            {
                vec.push_back(vec[cur]->m_lChild);
            }
            if (vec[cur]->m_rChild)
            {
                vec.push_back(vec[cur]->m_rChild);
            }
            cur++;
        }
        cout<<endl;
    }
}

//编程之美上的扩展问题2：
//从下往上层次遍历,并且每一层从右向左输出
void ReverseLevelTra1(Node* root)
{
    if (!root)
    {
        return;
    }
    vector<Node*> vec;
    vec.push_back(root);
    vec.push_back(NULL);
    int cur=0;
    int last=2;
    while (cur<vec.size()-1)
    {
        last=vec.size();
        while (cur<last)
        {
            if (vec[cur] && vec[cur]->m_lChild)
            {
                vec.push_back(vec[cur]->m_lChild);
            }
            if (vec[cur] && vec[cur]->m_rChild)
            {
                vec.push_back(vec[cur]->m_rChild);
            }
            cur++;
        }
        vec.push_back(NULL);
    }
    vec.pop_back();
    vec.pop_back();
    for (int i=vec.size()-1;i>=0;i--)
    {
        if (vec[i])
        {
            cout<<vec[i]->m_data<<"  ";
        }
        else
        {
            cout<<endl;
        }
    }
    cout<<endl;
}


//编程之美上的扩展问题1：
//从下往上层次遍历,并且每一层从左向右输出
void ReverseLevelTra2(Node* root)
{
    if (!root)
    {
        return;
    }
    vector<Node*> vec;
    vec.push_back(root);
    vec.push_back(NULL);
    int cur=0;
    int last=2;
    while (cur<vec.size()-1)
    {
        last=vec.size();
        while (cur<last)
        {
            if (vec[cur] && vec[cur]->m_rChild)
            {
                vec.push_back(vec[cur]->m_rChild);
            }
            if (vec[cur] && vec[cur]->m_lChild)
            {
                vec.push_back(vec[cur]->m_lChild);
            }
            cur++;
        }
        vec.push_back(NULL);
    }
    //这里需要注意最后vec中最后连个均为NULL，需要全pop出来
    vec.pop_back();
    vec.pop_back();
    for (int i=vec.size()-1;i>=0;i--)
    {
        if (vec[i])
        {
            cout<<vec[i]->m_data<<"  ";
        }
        else
        {
            cout<<endl;
        }
    }
    cout<<endl;
}

//利用二叉树的深度及打印二叉树的某层次的节点来
//从低向上层次遍历二叉树
void ReverseLevelTra3(Node* root)
{
    if (!root)
    {
        return;
    }
    int depth=Depth(root);
    for (int i=depth-1;i>=0;i--)
    {
        PrintNodeAtLevel(root,i);
        cout<<endl;
    }
}

int main()
{
    char* fileName="tree.txt";
    Node* pTree=CreateTree(fileName);
    InOrderTra(pTree);
    cout<<endl;
    PrintNodeAtLevel(pTree,2);
    cout<<endl;
    cout<<Depth(pTree)<<endl;
    LevelTra1(pTree);
    LevelTra2(pTree);
    LevelTra3(pTree);
    LevelTra4(pTree);
    ReverseLevelTra1(pTree);
    ReverseLevelTra2(pTree);
    ReverseLevelTra3(pTree);
}

//tree.txt文件内容为：
//1 2 4 -1 -1 5 7 -1 -1 8 -1 -1 3 -1 6 -1 -1
//构造出的树为编程之美P252图3-18的树

 

 

需要注意的问题如下：

1. 在构建二叉树的时候，二叉树在文件中按前序遍历存储，左右子树为空时，用-1表示。

2. 解决两个扩展题目并没有使用什么新方法，只是修改了书上的算法，首先将节点按层次存储在vector中，每一层之后存储一个NULL指针。

    然后从后向前遍历vector，输出节点。至于每一层节点输出是从左到右还是从右到左与代码中将左右子树压入vector的顺序有关。

3. 书中的处理方法，设置cur和last两个下标太巧妙了，在以后的学习中记得使用。

4. 二叉树相关算法首先想到递归，毕竟二叉树的定义都是递归形式。

5. 非递归方法一般要借助队列、栈来存储路径上的节点。

6. ReverseLevelTra3,利用树的深度，从低向上从左到右层次输出每一层的节点。如果要从右到左输出，需要修改PrintNodeAtLevel代码如下：

　　return PrintNodeAtLevel(root->m_rChild,level-1) | PrintNodeAtLevel(root->m_lChild,level-1);