c++数据结构--二叉树的应用

实验内容：

实现教材中算法5.4描述的二叉树创建算法，在此基础上实现二叉树的先序、后序递归遍历算法、两种非递归中序遍历、层序遍历、求二叉树的深度。

实验步骤：

（1）按照实验要求编写代码，构造二叉树。
（2）输入验收用例，验证其输出结果。

#include <iostream>
#ifndef DATA_STRUCTURE_STATUS_H
#include <stdio.h>
//状态码
#define TRUE              1
#define FALSE            0
#define OK                  1
#define ERROR           0
#endif
#ifndef OVERFLOW
#define OVERFLOW    -2
#endif // OVERFLOW
#ifndef NULL
#define NULL((void*) 0)
#endif // NULL
typedef int Status;
#define MAXSIZE 100
using namespace std;

typedef char TElemType;
typedef struct BiTNode
{
    TElemType data;//数据域
    struct BiTNode *lchild,*rchild;//左孩子，右孩子
}BiTNode,*BiTree;

typedef BiTNode* ElemType;


typedef struct QNode
{
    ElemType data;
    struct QNode *next;
}QNode,*QueuePtr;

typedef struct LQueue
{
    QueuePtr front;
    QueuePtr rear;
}LQueue;

Status InitQueue(LQueue &Q)
{
    Q.front=Q.rear=new QNode;
    Q.front->next=NULL;
    return OK;
}

Status Enqueue(LQueue &Q,ElemType e)
{
    QueuePtr q;
    q=new QNode;
    q->data=e;
    q->next=NULL;
    Q.rear->next=q;
    Q.rear=q;
    return OK;
}

Status Dequeue(LQueue &Q)
{
    if(Q.front==Q.rear)
    {
        return ERROR;
    }
    QNode* p;
    ElemType e;
    p=Q.front->next;
    e=p->data;
    Q.front->next=p->next;
    if(Q.rear==p)
    {
        Q.rear=Q.front;
    }
    delete p;
    return OK;
}

bool EmptyQueue(LQueue Q)
{
    if(Q.front==Q.rear)
        return true;
    return false;
}

ElemType GetHead(LQueue Q)
{
    if(Q.front==Q.rear)return ERROR;
    ElemType e;
    e=Q.front->next->data;
    return e;
}

void CreateBiTree(BiTree &T)
{//1.先序遍历创建二叉树
    char ch;
    cin>>ch;
    if(ch=='#')
    {
        T=NULL;
    }
    else{
        T=new BiTNode;
        T->data=ch;
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }

}

void PreOrderTraverse(BiTree T)
{//2.递归先序遍历算法
    if(T)
    {
        cout<<T->data;
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}

void PostOrderTraverse(BiTree T)
{//3.递归后序遍历算法
    if(T)
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        cout<<T->data;
    }
}

void InOrderTraverse(BiTree T)
{//4.中序遍历算法
    if(T)
    {
        InOrderTraverse(T->lchild);
        cout<<T->data;
        InOrderTraverse(T->rchild);
    }
}

void InOrderTree(BiTree T)
{//5.中序非遍历算法

    BiTree stack[100],p=T;//建立一个顺序栈，设置一个临时指针，并将指针p指向根节点;
    BiTree q;
    int top=0;//设置顺序栈的初始大小为0；

    while(top>0||p!=NULL)//循环条件，栈大小不为空或者p非空;
    {
        if(p!=NULL)//如果遇到非空二叉树,入栈，并沿着当前节点的左链遍历当前节点的左子树；
        {
            stack[++top]=p;
            p=p->lchild;
        }
        else{
        //如果遇到空的二叉树，就将指针出栈，并打印出出栈指针的值，并沿着当前节点的右链遍历当前节点的右子树；
            q=stack[top--];
            cout<<q->data;
            p=q->rchild;
        }
    }
}


void LevelOrderTree(BiTNode* T)
{
    LQueue Q;
    BiTNode* p;
    InitQueue(Q);
    Enqueue(Q,T);
    while(!EmptyQueue(Q))
    {
        p=GetHead(Q);
        putchar(p->data);
        if(p->lchild)
        {
            Enqueue(Q,p->lchild);
        }
        if(p->rchild)
        {
            Enqueue(Q,p->rchild);
        }
        Dequeue(Q);
    }
}

int Depth(BiTree T)
{
    if(T==NULL)return 0;
    else
    {
        int m=Depth(T->lchild);
        int n=Depth(T->rchild);
        if(m>n)
        return m+1;
        else
        {
            return n+1;
        }
    }
}

int main()
{
    int n,a;
    BiTree T;
    cout<<"1.创建二叉树(#代表空格)"<<endl;
    cout<<"2.先序遍历二叉树"<<endl;
    cout<<"3.中序遍历二叉树1"<<endl;
    cout<<"4.中序遍历二叉树2"<<endl;
    cout<<"5.后序遍历二叉树"<<endl;
    cout<<"6.层序遍历二叉树"<<endl;
    cout<<"7.求二叉树的深度"<<endl;
    cout<<"8.退出"<<endl;
    while(1)
    {
        cout<<"请输入你的选择：";
        cin>>a;
        switch (a)
        {
            case 1:
                CreateBiTree(T);
                cout<<"操作已完成！"<<endl;
                break;
            case 2:
                cout<<"先序遍历二叉树的顺序为：";
                PreOrderTraverse(T);
                cout<<"\n操作已完成！"<<endl;
                break;
            case 3:
                cout<<"中序递归遍历二叉树的顺序为：";
                InOrderTraverse(T);
                cout<<"\n操作已完成!"<<endl;
                break;
            case 4:
                cout<<"中序不递归遍历二叉树的顺序为：";
                InOrderTree(T);
                cout<<"\n操作已完成!"<<endl;
                break;
            case 5:
                cout<<"后序遍历二叉树的顺序为：";
                PostOrderTraverse(T);
                cout<<"\n操作已完成！"<<endl;
                break;
            case 6:
                cout<<"层序遍历二叉树的顺序为：";
                LevelOrderTree(T);
                cout<<"\n操作已完成！"<<endl;
                break;
            case 7:
                n=Depth(T);
                cout<<"二叉树的深度为："<<n<<endl;
                break;
            case 8:
                cout<<"本次操作结束！"<<endl;
                exit(0);

        }
    }
    return 0;
}