二叉排序树的判别（数据结构）

代码：

含注释，供参考

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

typedef struct Node
{
    int data;//数据
    struct Node*Lchild;//左子树
    struct Node*Rchild;//右子树
}*BiTree,BTNode;

typedef struct stacknode
{
    BTNode*Bi;//二叉树类型元素
    struct stacknode*next;//后继指针域
} Stack;

void CreateBiTree(BiTree*BT);//创建二叉树
void Judge(BiTree BT);//判断是否是排序二叉树
int Findmax(BiTree BT);//查找左子树的节点数据最大值
int Findmin(BiTree BT);//查找右子树的节点数据最小值
void Push(Stack*S,BiTree bt);//把bt压入栈
void Pop(Stack*S);//栈顶出栈

int judge=0;//排序二叉树标志

int main()
{
    BiTree B;
    CreateBiTree(&B);//创建二叉树
    Judge(B);//判断是否是排序二叉树
    if(judge==1)//等于 1 代表是排序二叉树，等于 0 不是
        printf("yes");
    else printf("no");
    return 0;
}

/*创建二叉树
 */
void CreateBiTree(BiTree*BT)
{
    int data;
    scanf("%d",&data);
    *BT=(BiTree)malloc(sizeof(BTNode));
    if(data!=-1)
    {
        (*BT)->data=data;
        CreateBiTree(&((*BT)->Lchild));//递归构造左子树
        CreateBiTree(&((*BT)->Rchild));//递归构造右子树
    }
    else *BT=NULL;
}

/*判断是否是排序二叉树
 */
void Judge(BiTree BT)
{
    Stack S;//栈
    BiTree P;
    int max,min;
    S.Bi=NULL;//初始化栈
    S.next=NULL;
    P=BT;
    do
    {
        while(P)
        {
            max=Findmax(P->Lchild);//左子树节点最大值
            min=Findmin(P->Rchild);//右子树节点最小值
            if(max>=P->data||min<=P->data)
                return;
            Push(&S,P);//把P压入栈
            P=P->Lchild;
        }
        if(S.Bi!=NULL)//栈不为空
        {
            P=S.Bi;//P 赋值为栈顶二叉树地址
            Pop(&S);//删除栈顶
            P=P->Rchild;//先序
        }
    }
    while(P||S.Bi);
    judge=1;//是排序二叉树
}

/*查找左子树的节点数据最大值
 */
int Findmax(BiTree BT)
{
    int MAX;
    if(BT)
    {
        MAX=BT->data;
        int m1,m2;
        m1=Findmax(BT->Lchild);//递归查找左子树最大值
        m2=Findmax(BT->Rchild);//递归查找右子树最大值
        m1=m1>m2?m1:m2;//将m1,m2最大值赋给m1
        MAX=MAX>m1?MAX:m1;//将m1,MAX最大值赋给MAX
        return MAX;
    }
    else return 0;
}

/*查找右子树的节点数据最小值
 */
int Findmin(BiTree BT)
{
    int MIN;
    if(BT)
    {
        MIN=BT->data;
        int m1,m2;
        m1=Findmin(BT->Lchild);//递归查找左子树最小值
        m2=Findmin(BT->Rchild);//递归查找右子树最小值
        m1=m1<m2?m1:m2;//将m1,m2最小值赋给m1
        MIN=MIN<m1?MIN:m1;//将m1,MAX最小值赋给MAX
        return MIN;
    }
    else return 32767;
}

/*把bt压入栈
 */
void Push(Stack*S,BiTree bt)
{
    Stack*insert;
    insert=(Stack*)malloc(sizeof(Stack));
    insert->Bi=bt;
    insert->next=S->next;
    S->next=insert;//修改栈顶指针
}

/*栈顶出栈
 */
void Pop(Stack*S)
{
    Stack*temp;
    temp=S->next;
    S->next=temp->next;
    free(temp);//释放空间
}