二叉树的封装

一.   源代码  BiTree.h

#include<iostream>
typedef char TElemType;  // 方便移植，方便控制树节点元素的数据类型
typedef TElemType   Tree_Data;//提高程序可读性
typedef  struct  BiTNode{    //定义存储结构，
    Tree_Data  data;
    struct BiTNode  *lchild,*rchild;
}BiTNode, *Tree;     //树的存储结构，在类的内部嵌套 
typedef Tree SElemType;//确定栈的数据元素
typedef Tree  QElemType;
#include "F:\A_Programer\DataStructure\Class\Stack.h"//包含栈的操作
#include "F:\A_Programer\DataStructure\Class\Queue_1.h"//包含队列操作
#include "F:\A_Programer\DataStructure\Class\Queue.h"//包含队列操作
using namespace std;
class BiTree
{
private:
    Tree T;
    Tree T1;
public:
    BiTree();//初始化一棵树
    void CreateBiTree_BF();//以广度优先建立一棵树
    bool ClearBiTree();//主动销毁一棵树
    void PreOrderTraverse(Tree t);//前序遍历
    void InOrderTraverse(Tree t);//中序遍历
    void PostOrderTraverse(Tree t);//后序遍历
    void PreOrderTraverse_Thr(Tree t);//前序遍历,线性
    void InOrderTraverse_Thr(Tree t);//中序遍历，线性
    void PostOrderTraverse_Thr(Tree t);//后序遍历，线性
    void LevelOrderTraverse();//广度优先遍历 BFS    层序遍历
    void LevelOrderTraverseT1();
    Tree GetTree();
    Tree GetTree1();
    ~BiTree();//被动销毁一棵树
};
BiTree::BiTree()
    {
        T=(Tree)new BiTNode;  //申请一个树节点，并强制类型转换，作为树的头结点
        T->lchild=NULL;//左子树置空
        T->rchild=NULL;//右子树置空
    }
void BiTree::LevelOrderTraverse()
{   
    /*
        思路：（参考书目ISB 978-7-118-05852）
        1. 访问元素所指结点
        2. 若该元素所指结点左右子树不空时，则将左右子树依次入队
        3. 不断循环，直到队列为空
    */
    Queue Q;//初始化队列,这个队列用来存放树的节点；
    Queue1 Q1;//初始化队列，这个队列用来存放节点编号，方便建立树；
    int lab=1;//第一个节点编号
    Q.EnterQueue(T);//将树根放入队列
    Q1.EnterQueue(lab);//赋予其编号
    while(!Q.IsEmpty())//结束条件
    {   
        Tree t;//临时变量，树节点
        int num;//临时变量，节点编号
        Q1.DeleteQueue(&num);//出队操作
        Q.DeleteQueue(&t);//出队操作
        cout<<num<<"节点的值"<<t->data<<endl;//输出节点的值
        if(t->lchild!=NULL)//队列先进先出，左子树先入队
        {
            Q.EnterQueue(t->lchild);//入队操作
            num=Q1.GetRear();//获取队位元素的值
            num++;//++便是此节点的编号
            Q1.EnterQueue(num);//入队
        }
        if(t->rchild!=NULL)//队列先进先出，右子树后入队
        {
            Q.EnterQueue(t->rchild);//入队操作
            num=Q1.GetRear();//获取队位元素的值
            num++;//++便是此节点的编号
            Q1.EnterQueue(num);//入队
        }
    }
}
void BiTree::CreateBiTree_BF()
{   
    /*
        关键注意
        1.  左子树先入队，右子树后入队
        2.  注意入队与出队时机
     */
    Queue Q;//初始化队列,这个队列用来存放树的节点
    Queue1 Q1;//初始化队列，这个队列用来存放节点编号，方便建立树
    int num=1;//第一个节点编号
    Q.EnterQueue(T);//将树根放入队列
    Q1.EnterQueue(num);//赋予其编号
    bool b;//用来判断是否具有左或右子树，由用户输入
    Tree t;//临时变量
    while(!Q.IsEmpty())//结束条件
    {   
        Q1.DeleteQueue(&num);//出对操作
        cout<<"请输入"<<num<<"节点的值"<<endl;//提示信息
        Q.DeleteQueue(&t);//出对操作
        cin>>t->data;//赋值
        cout<<"此节点是否具有左子树"<<endl;//提示信息
        cout<<"是           1"<<endl;
        cout<<"否           0"<<endl;
        cin>>b;//输入布尔量
        if(b)//如果有左子树，则先将其入队
        {
            Tree p=new BiTNode;//新建节点
            t->lchild=p;//赋值
            Q.EnterQueue(p);//入队
            num=Q1.GetRear();//获取队尾元素
            num++;//++便是该节点编号
            Q1.EnterQueue(num);//入队
        }
        else
            t->lchild=NULL;//赋值为空
        cout<<"是否具有右子树"<<endl;//提示信息
        cout<<"是           1"<<endl;
        cout<<"否           0"<<endl;
        cin>>b;//输入布尔量
        if(b)//如果有有子树，则后将其入队
        {
            Tree p=new BiTNode;//新建节点
            t->rchild=p;//赋值
            Q.EnterQueue(p);//入队
            num=Q1.GetRear();//获取队尾元素
            num++;//++便是该节点编号
            Q1.EnterQueue(num);//入队
        }
        else t->rchild=NULL;//赋值为空
    }
}
void BiTree::PreOrderTraverse( Tree t)
{   
    if(t)//结束条件
    {
        cout<<t->data<<endl;          //输出根节点的值
        PreOrderTraverse(t->lchild);  //访问左子树
        PreOrderTraverse(t->rchild);  //访问右子树
    }
}
Tree BiTree::GetTree()
{
    return this->T;
}
Tree BiTree::GetTree1()
{
    return this->T1;
}
void BiTree::InOrderTraverse(Tree t)
{
    if(t)//递归结束条件
    {
        InOrderTraverse(t->lchild);//首次寻找空树的左节点
        cout<<t->data<<endl;   //首次作为根访问   
        InOrderTraverse(t->rchild);//首次访问为空树的右节点
        //结束时以t为根节点的树已访问完毕
    }
}
void BiTree::PostOrderTraverse(Tree t)
{
    if(t)
    {
        PostOrderTraverse( t->lchild);  //   首次访问的树必定为一颗空树，代表此节点访问结束，在此基础上逐步递归，访问其他节点； 不管哪种递归方式，访问他的时候必定作为根，相对于空树
        PostOrderTraverse( t->rchild);
        cout<<t->data<<endl;
    }
}
void BiTree::PreOrderTraverse_Thr(Tree t)
{   
    /*
        先序遍历
        非递归实现方法
        思路如下：
        访问思路
        1. 不断访问根节点，并且压入栈，直到寻找第一课空树，，且这个空树树必定作为其所在树的左子树；
        2. 访问栈顶节点，如果栈顶节点的右孩子为空，则此节点已经失去价值，弹出； 否者，将其作为一颗新树访问，重复上述过程；
        3. 循结束环条件，栈空；
        我们应当重点考察的位置是 ***入栈时机与出栈时机***                           
    */
    Stack S;// 初始化栈
    S.Push(t);//将根节点入栈
    S.GetTop(&t);//获取栈顶元素
    while(!S.IsEmpty())//结束条件
    {
        while(t)//t==0,结束循环,即遇到左子树为空时停止循环
        {   
            cout<<t->data<<endl;//访问结点
            S.Push(t->lchild);//将左节点入栈
            S.GetTop(&t);//更新t
        }
        S.Pop(&t);//最后一次入栈的是一个空指针，出栈，当然这个语句还有其他巧妙的作用
        if(!S.IsEmpty())//栈不空，就出栈
        {
            S.Pop(&t);//出栈
            S.Push(t->rchild);//将其右孩子入栈，如果这值为NULL,S.Pop(&t);"    //最后一次入栈的是一个空指针，出栈，当然这个语句还有其他巧妙的作用 "  ,这就是巧妙之处
            S.GetTop(&t);//更新t
        }
        //S.Display();
    }
}
void BiTree::InOrderTraverse_Thr(Tree t)
{   
    /*
       思路：
         1.不断沿左子树深入，并且入栈；  直到遇到空左子树为止；
         2.访问此节点；  
         3.接着将此节点右子树入栈，并且将此节点出栈
         4.重复上述过程，直到栈空
    */
    Stack S;//初始化话栈
    S.Push(t);//根节点入栈
    while(!S.IsEmpty())//栈空为结束条件
    {
        S.GetTop(&t);//获取栈首元素
        while(t)//不断深入左子树，直到左子树为空树
        {
            t=t->lchild;//更新t
            S.Push(t);//将左子树入栈
        }
        S.Pop(&t);//最后一次入栈的是一个空指针，出栈，当然这个语句还有其他巧妙的作用
        if(!S.IsEmpty())//栈不空，就出栈
        {
            S.Pop(&t);//出栈
            cout<<t->data<<endl;//访问该节点
            S.Push(t->rchild);//将其右孩子入栈，如果这值为NULL,“S.Pop(&t);    //最后一次入栈的是一个空指针，出栈，当然这个语句还有其他巧妙的作用 "  ,这就是巧妙之处
        }
    }
}
void BiTree::PostOrderTraverse_Thr(Tree t)
{   
    /* 
       关键技术：
          采用节点保留技术，来判断是否访问当前节点
          在这个程序中采用pre来保留节点
          pre==NULL 这是其初值
          在此之后其的值都将为先前前访问过的节点
       思路：
          1.对于首个节点，现将自己入栈（根）
          2.处理栈顶元素
             （1）访问该节点的条件
                 【1】 当前节点的左右子树都为空；（t->lchild==NULL&&t->rchild==NULL） ，这个条件将用来第一次更新pre的值
                 【2】 pre!=NULL&&(t->rchild==pre||t->lchild==pre)
                       解释
                       *1 其中pre！=NULL ，主要作用起在第一次深入过程中，只有这样才能将所有元素入栈
                       *2 在第一次pre被更新后，这语句的作用更新为（或者说等同于，因为pre不可能再为NULL）t->rchild==pre||t->lchild==pre
                          第一层：  t->rchild==pre   
                                                在t的右子树且左子树存在的情况下，此语句起作用
                                                在t的右子树且左子树不存在的情况下，此语句也起作用（因为这俩种情况最先弹出的元素必定为节点的右子树）
                          第二层： t->lchild==pre
                                               当且仅当t只有左子树是时，语句起作用
                          
             （2）将右子树入栈（当然如果是空树就不入栈）！！！！ 很重要，后将左子树入栈 （当然如果是空树就不入栈）
          
    */
    Tree pre=NULL;  //初始化为空值
    Stack S;   //初始化栈
    S.Push(t); //将根节点入栈
    while(!S.IsEmpty())
    {   
        S.GetTop(&t);//更新t,处理栈首元素
        if((t->lchild==NULL&&t->rchild==NULL)||(pre!=NULL&&(t->rchild==pre||t->lchild==pre)))//出栈的情况，即是否可访问该节点的条件，否则继续深入
        {
            cout<<t->data<<endl;//访问该节点
            S.Pop(&t);//该节点失去存在的意义，出栈
            pre=t;//更新pre
        }
        else//继续入栈的情况
        {
            if(t->rchild!=NULL)//先将右子树入栈，空树不如栈
            {
                S.Push(t->rchild);
            }
            if(t->lchild!=NULL)//再将右子树入栈，空树不如栈，这个很关键
            {
                S.Push(t->lchild);
            }
        }
    }
}
BiTree::~BiTree()
{
    /*
        宽度优先删除节点
    */
    Tree t;//临时变量
    t=T;//将根节点赋值
    Queue Q;//初始化队列
    Q.EnterQueue(t);//入队
    while(!Q.IsEmpty())//结束条件
    {
        Q.DeleteQueue(&t);//处理队首元素
        if(t->lchild!=NULL)//榨取节点利用价值
        {
            Q.EnterQueue(t->lchild);//保存有效信息
        }
        if(t->rchild!=NULL)//榨取节点利用价值
        {
            Q.EnterQueue(t->rchild);//保存有效信息
        }
        free(t);//抛弃无用节点
    }
}

    几点 说明

          1.#include "F:\A_Programer\DataStructure\Class\Stack.h"//包含栈的操作       可参考我的其他随笔，有详细解释

         　　代码如下：

　　　　　　　　　

#pragma once
#include<iostream>
#include<cstring>
typedef  SElemType  Stack_Data;  //栈的数据类型
const int  Stack_Size=50;   //栈的最大存储量
using namespace std;
class Stack               
{  
private:
     Stack_Data Data[Stack_Size];
     int Top;
public:
    Stack(); //初始化栈
    bool IsEmpty();//判空
    bool IsFull();//判满
    void Push(Stack_Data e);// 入栈
    bool Pop(Stack_Data *e);//出栈
    void GetTop(Stack_Data *e);//取栈顶元素
    void Display();//展示函数
    int  TopLocation();//获取Top
};
Stack::Stack()
{
    Top=0;
}
bool Stack:: IsEmpty()
{
    if(Top==0)
    {
        return true;
    }
    else 
        return false;
}
bool Stack::IsFull()
{
    if(Top==Stack_Size-1)
    {
        return true;
    }
    else 
        return false;
}
void Stack::Push(Stack_Data e)
{
    if(!IsFull())
    {
        Top++;
        Data[Top]=e;
    }
    else
        cout<<"Stack OverFlow"<<endl;
}   
bool Stack::Pop(Stack_Data *e)
{
    if(!IsEmpty())
    {
        *e=Data[Top];
        Top--;
        return true;
    }
    else
        cout<<"Defeat"<<endl;
        return false; 
}
void Stack::GetTop(Stack_Data *e)
{
     if(!IsEmpty())
     {
         *e=Data[Top];
     }
     else 
         cout<<"Defeat"<<endl;
}
void Stack::Display()
{   
    if(!IsEmpty())
    {
        int temp=Top;
        while(temp)
        {
            cout<<"Data["<<temp<<"]   "<<Data[temp]->data<<endl;
            temp--;
        }
    }
    else
        cout<<"False"<<endl;
}
int  Stack::TopLocation()
{
    return Top;
}

 2. #include "F:\A_Programer\DataStructure\Class\Queue.h"//包含队列操作      可参考我的其他随笔，有详细解释

  

#pragma once
#include<iostream>
using namespace std;
#define QMaxSize 100  //队列最大容量
typedef QElemType   Queue_Data;   //队列存储元素类型
typedef struct QueueNode               //存储结构
{
    Queue_Data data[QMaxSize];
    int front;
    int rear;
    int count;
}QueueNode,*Que;
class  Queue
{
private:
    Que  Q;
public:
    Queue();//初始化空的队列
    bool EnterQueue(Queue_Data e);// 入队操作
    bool DeleteQueue(Queue_Data *e);//出队操作；
    bool IsEmpty();//判空
    bool IsFull();//判满
    void Display();
};
Queue::Queue()
    {  
        Q=new QueueNode;
        Q->front=0;
        Q->rear=0;
        Q->count=0;
    }
bool Queue::EnterQueue(Queue_Data e)
{
    if(!IsFull())//如果队列不满的话，增加元素
    {
        Q->count++;//计数器示数即为队列元素个数
        Q->data[Q->rear]=e;//队尾指针所指空间即为下一个入队元素的存放位置
        Q->rear=(Q->rear+1)%QMaxSize;//队列的精华
        return true;
    }
    else return false;
}
bool Queue::DeleteQueue(Queue_Data *e)
{
    if(!IsEmpty())//如果队列不为空，操作合法
    {
        *e=Q->data[Q->front];//队首指针指示位置即为要出队元素的位置
        Q->front=(Q->front+1)%QMaxSize;//这里容易出错，切记是加一
        Q->count--;
        return true;
    }
    else return false;
}
bool Queue::IsEmpty()
{
    if(Q->count==0)//判空最简单的一种计数器方法
        return true;
    else 
        return false;
}
bool Queue::IsFull()
{
    if(Q->count==QMaxSize)//判满，计数器
        return true;
    else 
        return false;
}
void Queue::Display()
{  
    int b;
    int p;
    b=Q->count;
    p=Q->front;
    while(b)
    {
        cout<<Q->data[p]<<endl;
        p=(p+1)%QMaxSize;
        b--;
    }
}

3.#include "F:\A_Programer\DataStructure\Class\Queue_1.h"//包含队列操作

 

#include<iostream>
using namespace std;
#define QMaxSize_1 100  //队列最大容量
typedef int  QElemType_1;
typedef QElemType_1   Queue_Data_1;  //队列存储元素类型
typedef struct QueueNode1                //存储结构
{
    Queue_Data_1 data[QMaxSize_1];
    int front;
    int rear;
    int count;
}QueueNode_1,*Que_1;
class  Queue1
{
private:
    Que_1  Q;
public:
    Queue1();//初始化空的队列
    bool EnterQueue(Queue_Data_1 e);// 入队操作
    bool DeleteQueue(Queue_Data_1 *e);//出队操作；
    bool IsEmpty();//判空
    bool IsFull();//判满
    Queue_Data_1 GetRear();
    void Display();
};
Queue1::Queue1()
    {  
        Q=new QueueNode1;
        Q->front=0;
        Q->rear=0;
        Q->count=0;
    }
bool Queue1::EnterQueue(Queue_Data_1 e)
{
    if(!IsFull())//如果队列不满的话，增加元素
    {
        Q->count++;//计数器示数即为队列元素个数
        Q->data[Q->rear]=e;//队尾指针所指空间即为下一个入队元素的存放位置
        Q->rear=(Q->rear+1)%QMaxSize_1;//队列的精华
        return true;
    }
    else return false;
}
bool Queue1::DeleteQueue(Queue_Data_1 *e)
{
    if(!IsEmpty())//如果队列不为空，操作合法
    {
        *e=Q->data[Q->front];//队首指针指示位置即为要出队元素的位置
        Q->front=(Q->front+1)%QMaxSize_1;//这里容易出错，切记是加一
        Q->count--;
        return true;
    }
    else return false;
}
bool Queue1::IsEmpty()
{
    if(Q->count==0)//判空最简单的一种计数器方法
        return true;
    else 
        return false;
}
bool Queue1::IsFull()
{
    if(Q->count==QMaxSize_1)//判满，计数器
        return true;
    else 
        return false;
}
void Queue1::Display()
{  
    int b;
    int p;
    b=Q->count;
    p=Q->front;
    while(b)
    {
        cout<<Q->data[p]<<endl;
        p=(p+1)%QMaxSize_1;
        b--;
    }
}
Queue_Data_1  Queue1::GetRear()
{
    return  this->Q->data[this->Q->rear-1];
}

 

二.测试代码及输入文件

1. 测试代码（主函数）

int main()
{   
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    BiTree  T;
    T.CreateBiTree_BF();
    T.LevelOrderTraverse();
    T.PreOrderTraverse(T.GetTree());
    cout<<endl;
    T.InOrderTraverse(T.GetTree());
    cout<<endl;
    T.PostOrderTraverse(T.GetTree());
    cout<<endl;
    T.PreOrderTraverse_Thr(T.GetTree());
    cout<<endl;
    T.InOrderTraverse_Thr(T.GetTree());
    cout<<endl;
    T.PostOrderTraverse_Thr(T.GetTree());
    cout<<endl;
    return 0;
}

2. in.txt

1
1
1
2
1
0
3
1
1
4
0
1
5
0
0
6
0
0
7
0
0

3. 测试树的结构

  

三. 测试结果

out.txt

请输入1节点的值
此节点是否具有左子树
是           1
否           0
是否具有右子树
是           1
否           0
请输入2节点的值
此节点是否具有左子树
是           1
否           0
是否具有右子树
是           1
否           0
请输入3节点的值
此节点是否具有左子树
是           1
否           0
是否具有右子树
是           1
否           0
请输入4节点的值
此节点是否具有左子树
是           1
否           0
是否具有右子树
是           1
否           0
请输入5节点的值
此节点是否具有左子树
是           1
否           0
是否具有右子树
是           1
否           0
请输入6节点的值
此节点是否具有左子树
是           1
否           0
是否具有右子树
是           1
否           0
请输入7节点的值
此节点是否具有左子树
是           1
否           0
是否具有右子树
是           1
否           0
1节点的值1
2节点的值2
3节点的值3
4节点的值4
5节点的值5
6节点的值6
7节点的值7
1
2
4
7
3
5
6

4
7
2
1
5
3
6

7
4
2
5
6
3
1