5-31 笛卡尔树

#include<stdio.h>
#include<stdlib.h>
#define MAXN 1000
typedef int ElemType;
typedef struct tnode
{
    ElemType K1;
    ElemType K2;
    int left;
    int right;
}Tree;
Tree T[MAXN];
typedef struct snode
{
    ElemType data[MAXN];
    int top;
}*Stack;
/*void Check_K1(int root,int *tag)
{
    int L,R;
    if(-1==T[root].left&&-1==T[root].right)
        return;
    else if(-1==T[root].left)
    {
        R=T[root].right;
        if(T[R].K1<=T[root].K1)
        {
            *tag=1;
            return;
        }
        else
            Check_K1(R,tag);
    }
    else if(-1==T[root].right)
    {
        L=T[root].left;
        if(T[L].K1>=T[root].K1)
        {
            *tag=1;
            return;
        }
        else
            Check_K1(L,tag);
    }
    else
    {
        R=T[root].right;
        L=T[root].left;
        if(T[L].K1<T[root].K1&&T[R].K1>T[root].K1)
        {
            Check_K1(L,tag);
            Check_K1(R,tag);
        }
        else
        {
            *tag=1;
            return;
        }
    }

}*/
void Push(Stack s,ElemType item)
{
    s->data[++s->top]=item;
}
void Inorder(Stack s,int root)
{
    if(-1!=root)
    {
        if(-1!=T[root].left)
            Inorder(s,T[root].left);
        Push(s,T[root].K1);
        if(-1!=T[root].right)
            Inorder(s,T[root].right);
    }
    else
        return;
}
void Check_K2(int root,int *tag)
{
    int L,R;
    if(-1==T[root].left&&-1==T[root].right)
        return;
    else if(-1==T[root].left)
    {
        R=T[root].right;
        if(T[R].K2<=T[root].K2)
        {
            *tag=1;
            return;
        }
        else
            Check_K2(R,tag);
    }
    else if(-1==T[root].right)
    {
        L=T[root].left;
        if(T[L].K2<=T[root].K2)
        {
            *tag=1;
            return;
        }
        else
            Check_K2(L,tag);
    }
    else
    {
        R=T[root].right;
        L=T[root].left;
        if(T[L].K2>T[root].K2&&T[R].K2>T[root].K2)
        {
            Check_K2(L,tag);
            Check_K2(R,tag);
        }
        else
        {
            *tag=1;
            return;
        }
    }

}
int main()
{
    int i,N,number[MAXN]={0},root,tag1,tag2;
    Stack s;
    s=malloc(sizeof(struct snode));
    s->top=-1;
    scanf("%d",&N);
    for(i=0;i<N;i++)
    {
        scanf("%d %d %d %d",&T[i].K1,&T[i].K2,&T[i].left,&T[i].right);
        if(-1!=T[i].left)
            number[T[i].left]=1;
        if(-1!=T[i].right)
            number[T[i].right]=1;
    }
    for(i=0;i<N;i++)
    {
        if(!number[i])
        {
            root=i;
            break;
        }
    }
    tag1=0;
    //Check_K1(root,&tag1);
    Inorder(s,root);
    for(i=0;i<N-1;i++)
    {
        if(s->data[i]>=s->data[i+1])
        {
            tag1=1;
            break;
        }
    }
    tag2=0;
    Check_K2(root,&tag2);
    if(!tag2&&!tag1)
        printf("YES\n");
    else
        printf("NO\n");
}

我这里开始犯了一个致命的问题导致有一个测试案例不能通过。在检查K1是否满足二叉搜索树的性质时，我开始用的方法是比较根节点的K1与其左右孩子K1的相对大小，若根节点K1居中，则递归调用左右子树；否则标志tag1置为1返回。这个错误的根源在于，二叉搜索树的根节点的K1不仅仅要大于左孩子和小于右孩子，而是要大于左子树所有结点的K1和小于右子树所有结点的K1。