【oj】8608 实现二叉排序树的各种算法

8608 实现二叉排序树的各种算法

新人的第一篇blog，写得不好请大佬们谅解
各位这么喜欢临时抱佛脚的吗？？今晚为什么访问量翻了一倍？

实现如下二叉排序树算法：
（1） 插入新结点
（2） 前序、中序、后序遍历二叉树
（3） 中序遍历的非递归算法
（4） 层次遍历二叉树
（5） 在二叉树中查找给定关键字(函数返回值为成功1,失败0)
（6） 交换各结点的左右子树
（7） 求二叉树的深度
（8） 叶子结点数

这是cpp文件，但是为了巩固我基本用C语言
基本上都是用指针来操控它所指的空间，使用分配栈和队的存储的类型都是指针：(BSTnode**)malloc(sizeof(BSTnode*)*n)

建议大家自己动手做，不要照抄

#include <stdio.h>
#include <stdlib.h>

typedef struct BSTnode//二叉排序树
{
   int data;
   struct BSTnode *lchild,*rchild;
} BST,*BiTree;
typedef struct//栈
{
    BiTree* base;
    BiTree* top;
    int Ssize;
}Sqstack;
typedef struct//队
{
    BiTree* base;
    int qfront;
    int qrear;
}SqQueue;
void InitStack(Sqstack &S,int n)//栈的初始化
{
    S.base=(BiTree*)malloc(sizeof(BiTree)*n);
    //申请一块类型为二叉排序树的指针的空间。
    if(!S.base) exit(0);//申请失败
    S.top=S.base;//初始化为空栈
    S.Ssize=n;//n为二叉排序树的结点个数
}
void InitQueue(SqQueue &Q,int n)//队的初始化
{
    Q.base=(BiTree*)malloc(sizeof(BiTree)*n);
    //申请一块类型为二叉排序树的指针的空间。
    Q.qfront=Q.qrear=0;
    //初始化为空栈
}
int isQEmpty(SqQueue &Q)//队为空
{
    if(Q.qfront==Q.qrear) return 1;
    else return 0;
}
void EnQueue(SqQueue &Q,BiTree e)//入队
{
    Q.base[Q.qrear]=e;
    //在地址为基地址+Q.qrear的空间放入指针
    Q.qrear++;
}
int DeQueue(SqQueue &Q,BiTree &e)//出队
{
    if(Q.qfront==Q.qrear) return 0;//空队
    else {
    e=Q.base[Q.qfront];
    Q.qfront++;
    return 1;
    }
}
int Push(Sqstack &S,BiTree e)//入栈
{
    if(S.top-S.base==S.Ssize) return 0;//栈满
    else {
        *S.top=e;
        S.top++;
        return 1;
    }
}
int Pop(Sqstack &S,BiTree &q)//出栈
{
    if(S.top==S.base) return 0;
    else {
        S.top--;
        q=*S.top;
        return 1;
    }
}
int isStackEmpty(Sqstack &S)//栈为空
{
    if(S.base==S.top) return 1;
    else return 0;
}
void insertBst(BiTree &T,int e)//二叉树的插入
{
    if(!T)
    {
        BiTree s=(BiTree)malloc(sizeof(BST));//分配内存
        s->data=e;
        s->lchild=NULL;
        s->rchild=NULL;
        T=s;
    }
    else{
        if(e>T->data) insertBst(T->rchild,e);
        else insertBst(T->lchild,e);
        
    }
}
void PreOrderTraverse(BiTree &T)   //先序  
{
  if(T)
  {
      printf("%d ",T->data);
      PreOrderTraverse(T->lchild);
      PreOrderTraverse(T->rchild);
  }
}
void InOrderTraverse(BiTree &T)//中序
{
    if(T)
    {
        InOrderTraverse(T->lchild);
        printf("%d ",T->data);
        InOrderTraverse(T->rchild);
    }
}
void PostOrderTraverse(BiTree &T)//后序
{

    if(T)
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        printf("%d ",T->data);
    }
}
void SearchBst(BiTree &T,int sech)//查找
{
    if(T)
    {
        if(T->data==sech) printf("1\n");
        else if(T->data>sech) SearchBst(T->lchild,sech);
        else SearchBst(T->rchild,sech);
    }
    else printf("0\n");
}
void InOrderTraverseNR(BiTree &T,int n)//中序非递归遍历  
{
    Sqstack S;
    InitStack(S,n);
    BiTree p=T;
    BiTree q=(BiTree)malloc(sizeof(BST));
    while(p||!isStackEmpty(S))
    {
        if(p)
        {
              Push(S,p);
              p=p->lchild;
        }
        else
        {
            Pop(S,q);
            printf("%d ",q->data);
            p=q->rchild;
        }
    }

}

void  LevelTraverse(BiTree &T,int n)//层序遍历
{
       SqQueue Q;
       InitQueue(Q,n);
       BiTree a=T;
       EnQueue(Q,a);
       while(!isQEmpty(Q))
       {
           DeQueue(Q,a);
           printf("%d ",a->data);
           if(a->lchild)//左孩子存在
           EnQueue(Q,a->lchild);
           if(a->rchild)//右孩子存在
           EnQueue(Q,a->rchild);
       }
}
void ChangeBst(BiTree &T)//交换左右子树
{
   BiTree temp;
   if(T)
   {
   temp=T->lchild;
   T->lchild=T->rchild;
   T->rchild=temp;
   ChangeBst(T->lchild);
   ChangeBst(T->rchild);
   }
}
void Traverse(BiTree &T)//先序、中序、后序排序
{
    PreOrderTraverse(T);
    printf("\n");
    InOrderTraverse(T);
    printf("\n");
    PostOrderTraverse(T);
    printf("\n");
}
int DeepthBST(BiTree &T)//树的深度
{
    int m=0,n=0;//?
    if(T)
    {
        m=DeepthBST(T->lchild);
        n=DeepthBST(T->rchild);
        if(m>=n) return m+1;
        else return n+1;
    }
    else return 0;
}
void NodeBST(BiTree &T,int &node)//叶子结点的个数
{
    if(T)
    {
        if(!T->lchild&&!T->rchild)
        node++;
        else{
             NodeBST(T->lchild,node);
             NodeBST(T->rchild,node);
        }

    }
}
int main()
{
    int n,i,temp;
    scanf("%d",&n);
    BiTree t=NULL;
    for(i=0;i<n;i++)
    {
       scanf("%d",&temp);
       insertBst(t,temp);
    }
    Traverse(t);//先中后
    int sech1,sech2;
    scanf("%d",&sech1);
    n++;
    SearchBst(t,sech1);//查找
    scanf("%d",&sech2);
    n++;
    SearchBst(t,sech2);//查找
    scanf("%d",&temp);
    insertBst(t,temp);//插入新结点
    Traverse(t);//先序、中序、后序
    InOrderTraverseNR(t,n);//中序非递归
    printf("\n");
    LevelTraverse(t,n);//层次遍历
    printf("\n");
    ChangeBst(t);//交换结点
    Traverse(t);//先中后
    ChangeBst(t);//交换结点
    Traverse(t);//先中后
    int deepth=0,node=0;
    deepth=DeepthBST(t);//深度
    printf("%d\n",deepth);
    NodeBST(t,node);//叶子结点个数
    printf("%d",node);
    return 0;
}