树的基本操作

/*本实验函数包括
1.先序遍历建立二叉树（有无返回值的函数）
2.先序遍历递归算法
3.中序遍历递归算法
4.后序遍历递归算法
5.计算深度
6.计算结点个数,叶子结点数 
7.补充.复制二叉树 
8.栈的相关函数 
9.中序遍历的非递归算法 
10.二叉树左右子树的交换*/

#include<iostream>
#include<stdlib.h>
const int MAXSIZE = 100;
using namespace std;

//定义结点
struct BiTNode
{
    char data;
    struct BiTNode *lchild, *rchild;
};

//定义树
typedef BiTNode* BiTree;


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


//补.先序遍历建立二叉树(带返回值)
BiTree CreateBiTree()
{
    BiTree T;
    char ch;
    cin>>ch;
    if (ch == '#') T = NULL;
    else
    {
        T = new BiTNode;
        T->data = ch;
        T->lchild = CreateBiTree();
        T->rchild = CreateBiTree();
    }
    return T;//需要在主函数里用BiTree T接收
}


//2.先序遍历的递归算法
void PreOrderTraverse(BiTree T)
{
    if (T)
    {
        printf("%c", T->data);
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}


//3.中序遍历的递归算法
void InOrderTraverse1(BiTree T)
{
    if (T)
    {
        InOrderTraverse1(T->lchild);
        printf("%c", T->data);
        InOrderTraverse1(T->rchild);
    }
}


//4.后序遍历的递归算法
void PostOrderTraverse(BiTree T)
{
    if (T)
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        printf("%c", T->data);
    }
}


//5计算二叉树的深度
int Depth(BiTree T)
{
    int m, n;
    if (T == NULL) return 0;
    else
    {
        m = Depth(T->lchild);
        n = Depth(T->rchild);
        return m > n ? (m + 1) : (n + 1);
    }
}


//6.统计二叉树的结点个数
int NodeCount(BiTree T)
{
    if (T == NULL)
        return 0;
    else return NodeCount(T->lchild) + NodeCount(T->rchild) + 1;
}


//补.统计叶子节点数
int LeafNode(BiTree T)
{
    int num1, num2;
    if (T == NULL)
        return 0;
    else if (T->lchild == NULL && T->rchild == NULL)
        return 1;
    else
    {
        num1 = LeafNode(T->lchild);
        num2 = LeafNode(T->rchild);
        return (num1 + num2);
    }
}


//7.补充 复制二叉树
void Copy(BiTree T, BiTree &NewT)
{
    //复制一棵完全相同的二叉树
    if (T == NULL)
    {
        NewT = NULL;
    }
    else
    {
        NewT = new BiTNode;
        NewT->data = T->data;
        Copy(T->lchild, NewT->lchild);
        Copy(T->rchild, NewT->rchild);
    }
}


//8.栈的相关定义及函数
struct SqStack
{
    BiTNode *base;
    BiTNode *top;
    int stacksize;
};
//初始化
void InitStack(SqStack &S)
{
    S.base = new BiTNode;
    S.top = S.base;
    S.stacksize = MAXSIZE;
}
//入栈
void Push(SqStack &S, BiTNode e)
{
    if (S.top - S.base == MAXSIZE) cout<<"栈满，入栈失败";
    *S.top = e; S.top++;
    //S.top++=e;
}
//出栈
void Pop(SqStack &S, BiTNode *q)
{
    if (S.top == S.base) printf("空栈，出栈失败");
    *q = *--S.top;
}
//判空
int StackEmpty(SqStack S)
{
    if (S.top == S.base) return 1;
    else return 0;
}


//9.中序遍历的非递归算法
void InOrderTraverse2(BiTree T)
{
    SqStack S;
    BiTNode *p, *q;
    InitStack(S);
    p = T;
    q = new BiTNode;
    while (p || !StackEmpty(S))
    {
        if (p)
        {
            Push(S, *p);
            p = p->lchild;
        }
        else
        {
            Pop(S, q);
            cout<<q->data;
            p = q->rchild;
        }
    }


}


//10.二叉树的左右子树交换
void Exchange(BiTree &T)//采用先序遍历的思想
{
    if (T)
    {
        BiTree term;//用相同的数据类型来记录
        term = T->lchild;
        T->lchild = T->rchild;
        T->rchild = term;
        Exchange(T->lchild);
        Exchange(T->rchild);
    }
}
int main()
{
    BiTree T, NewT1, NewT2;
    CreateBiTree(T);
    cout<<"****************";


    cout<<"\n前序遍历：";
    PreOrderTraverse(T);


    cout<<"\n中序遍历：";
    InOrderTraverse1(T);


    cout<<"\n后序遍历：";
    PostOrderTraverse(T);


    cout<<"\n树的深度是"<<Depth(T);


    cout<<"\n树的结点个数是"<<NodeCount(T);


    cout<<"\n叶子结点个数是"<<LeafNode(T);


    Copy(T, NewT1);
    cout<<"\n复制后的二叉树先序遍历是：";
    PreOrderTraverse(NewT1);


    cout<<"\n中序非递归遍历：";
    InOrderTraverse2(T);


    Exchange(T);
    cout<<"\n左右孩子交换后的二叉树：";
    cout<<"先序遍历：";
    PreOrderTraverse(T);
    cout<<"中序遍历：";
    InOrderTraverse2(T);

    system("pause");
    return 0;
}
//abc##de#g##f###