二叉树的前中后层次遍历

代码如下：

首先是层次遍历需要用到的队列cirqueue.h的头文件

#pragma once
#include <iostream>
template<class T>
class Queue {
// FIFO 对象
public :
Queue(int MaxQueueSize = 10);
~Queue() {delete [] queue;}
bool IsEmpty() const {return front == rear;}
bool IsFull() const {return (
((rear + 1) % MaxSize == front) ? 1 : 0);}
T First() const; //返回队首元素
T Last() const; // 返回队尾元素
Queue<T>& Add(const T& x);
Queue<T>& Delete(T& x);
int front; //与第一个元素在反时针方向上相差一个位置
int rear; // 指向最后一个元素
int MaxSize; // 队列数组的大小
T *queue; // 数组
} ;

template<class T>
Queue<T>::Queue(int MaxQueueSize)
{// 创建一个容量为 M a x Q u e u e S i z e的空队列
MaxSize = MaxQueueSize + 1;
queue = new T[MaxSize];
front = rear = 0;
}
template<class T>
T Queue<T>::First() const
{// 返回队列的第一个元素
// 如果队列为空，则引发异常O u t O f B o u n d s
if (IsEmpty()) throw "OutOfBounds()";
return queue[(front + 1) % MaxSize];
}
template<class T>
T Queue<T>::Last() const
{// 返回队列的最后一个元素
// 如果队列为空，则引发异常O u t O f B o u n d s
if (IsEmpty()) throw "OutOfBounds()";
return queue[rear];
}
template<class T>
Queue<T>& Queue<T>::Add(const T& x)
{// 把 x 添加到队列的尾部
// 如果队列满，则引发异常 NoMem 
if (IsFull()) throw "NoMem()";
rear = (rear + 1) % MaxSize;
queue[rear] = x;
return *this;
}
template<class T>
Queue<T>& Queue<T>::Delete(T& x)
{// 删除第一个元素，并将其送入 x
// 如果队列为空，则引发异常 O u t O f B o u n d s
if (IsEmpty()) throw "OutOfBounds()";
front = (front + 1) % MaxSize;
x = queue[front];
return *this;
}

2.接下来是二叉树前中后以及层次遍历的主要代码 bitree.h的头文件

#include "cirqueue.h"
#pragma once
#include <iostream>
using namespace std;
// 二叉链表的节点
template<class T>
struct BiNode
{
    T data;    // 数据域
    BiNode<T>*lchild, *rchild;    // 左右指针域
};
// 二叉链表类实现
template<class T>
class BiTree
{
public:
    BiTree() { root = Creat(root); }        // 构造函数，建立一颗二叉树
    ~BiTree() { Release(root); }            // 析构函数，释放各节点的存储空间
    void PreOrder() { PreOrder(root); }      // 递归前序遍历二叉树
    void InOrder() { InOrder(root); }        // 递归中序遍历二叉树
    void PostOrder() { PostOrder(root); }    // 递归后序遍历二叉树
    void LeverOrder();                       // 层序遍历二叉树
private:
    BiNode<T>* root;                        // 指向根节点的头节点
    BiNode<T>* Creat(BiNode<T>* bt);        // 构造函数调用
    void Release(BiNode<T>* bt);            // 析构函数调用
    void PreOrder(BiNode<T>* bt);           // 前序遍历函数调用
    void InOrder(BiNode<T>* bt);            // 中序遍历函数调用
    void PostOrder(BiNode<T>* bt);          // 后序遍历函数调用
};

template<class T>
inline void BiTree<T>::LeverOrder()
{
    Queue<BiNode<T>*> Q;    // 定义一个队列
    Q.front=Q.rear=-1;    // 顺序队列
    if (root == NULL)
        return;
    Q.queue[++Q.rear]=root;// 根指针入队　
    while (Q.front != Q.rear)
    {
        BiNode<T>* q = Q.queue[++Q.front];    // 出队
        cout<<q->data;
        if (q->lchild != NULL)
            Q.queue[++Q.rear] = q->lchild;    // 左孩子入队
        if (q->rchild != NULL)
            Q.queue[++Q.rear] = q->rchild;    // 右孩子入队
    }
    
}

template<class T>
inline BiNode<T>* BiTree<T>::Creat(BiNode<T>* bt)
{
    T ch;
    cin>>ch;// 输入结点的数据信息，假设为字符
    if(ch=='#')
       bt=NULL;
    else
    {
        bt=new BiNode<T>;// 生成一个结点，数据域为ch
        bt->data = ch;
        bt->lchild=Creat(bt->lchild);// 递归建立左子树
        bt->rchild=Creat(bt->rchild);// 递归建立右子树
    }
    return bt;
}

template<class T>
inline void BiTree<T>::Release(BiNode<T>* bt)
{
    if (bt != NULL)
    {
        Release(bt->lchild);// 释放左子树
        Release(bt->rchild);// 释放右子树
        delete bt;// 释放根节点
    }
}

template<class T>
inline void BiTree<T>::PreOrder(BiNode<T>* bt)
{
    if (bt == NULL)// 递归调用的结束条件
        return;
    cout << bt->data;// 访问根节点bt的数据域
    PreOrder(bt->lchild);// 前序递归遍历bt的左子树
    PreOrder(bt->rchild);// 前序递归遍历bt的右子树
}

template<class T>
inline void BiTree<T>::InOrder(BiNode<T>* bt)
{
    if (bt == NULL)
        return;
    InOrder(bt->lchild);
    cout << bt->data;
    InOrder(bt->rchild);
}

template<class T>
inline void BiTree<T>::PostOrder(BiNode<T>* bt)
{
    if (bt == NULL)
        return;
    PostOrder(bt->lchild);
    PostOrder(bt->rchild);
    cout << bt->data;
}

3.main.cpp文件

#include"bitree.h"
using namespace std;

int main()
{
    BiTree<char>* bitree=new BiTree<char>();        // 创建一棵二叉树
    bitree->PreOrder();                             // 前序遍历
    cout << endl;
    bitree->InOrder();                              // 中序遍历
    cout << endl;
    bitree->PostOrder();                            // 后序遍历
    cout << endl;
    bitree->LeverOrder();                           // 层序遍历
    delete bitree;

    system("pause");
    return 0;
}