【数据结构C语言】二叉树的遍历

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

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100


typedef struct BiTNode
{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;




//1.先序遍历建立二叉树
void CreateBiTree(BiTree *T)
{
    char ch;
    scanf("%c",&ch);
    if(ch=='#') *T=NULL;
    else
    {
        *T=(BiTNode *)malloc(sizeof(BiTNode));
        (*T)->data=ch;
        CreateBiTree(&(*T)->lchild);
        CreateBiTree(&(*T)->rchild);
    }
}
//函数1心得：要想改变BiTree T的值，函数的形参必须是比它高一级，即写它的地址


//补.先序遍历建立二叉树(带返回值)
BiTree CreateBiTree()
{
    BiTree T;
    char ch;
    scanf("%c",&ch);
    if(ch=='#') T=NULL;
    else
    {
        T=(BiTNode *)malloc(sizeof(BiTNode));
        T->data=ch;
        T->lchild=CreateBiTree();
        T->rchild=CreateBiTree();
    }
    return T;//需要在主函数里用BBiTree 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=(BiTNode *)malloc(sizeof(BiTNode));
        (*NewT)->data=T->data;
        Copy(T->lchild,&(*NewT)->lchild);
        Copy(T->rchild,&(*NewT)->rchild);
    }
}






//8.栈的相关定义及函数
typedef struct
{
    BiTNode *base;
    BiTNode *top;
    int stacksize;
}SqStack;
//初始化
void InitStack(SqStack &S)
{
    S.base=(BiTNode *)malloc(sizeof(BiTNode)*MAXSIZE);
    S.top=S.base;
    S.stacksize=MAXSIZE;
}
//入栈
void Push(SqStack &S,BiTNode e)
{
    if(S.top-S.base==MAXSIZE) printf("栈满，入栈失败");
    *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=(BiTNode *)malloc(sizeof(BiTNode));
    while(p||!StackEmpty(S))
    {
        if(p)
        {
            Push(S,*p);
            p=p->lchild;
        }
        else
        {
            Pop(S,q);
            printf("%c",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);
    printf("****************");


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


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


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


    printf("\n树的深度是%d",Depth(T));


    printf("\n树的结点个数是%d",NodeCount(T));


    printf("\n叶子结点个数是%d",LeafNode(T));


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


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


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


    return 0;
}
//abc##de#g##f###