5-31 笛卡尔树 (25分)

5-31 笛卡尔树 (25分)

笛卡尔树是一种特殊的二叉树，其结点包含两个关键字K1和K2。首先笛卡尔树是关于K1的二叉搜索树，即结点左子树的所有K1值都比该结点的K1值小，右子树则大。其次所有结点的K2关键字满足优先队列（不妨设为最小堆）的顺序要求，即该结点的K2值比其子树中所有结点的K2值小。给定一棵二叉树，请判断该树是否笛卡尔树。
输入格式:

输入首先给出正整数N（≤1000），为树中结点的个数。随后N行，每行给出一个结点的信息，包括：结点的K1值、K2值、左孩子结点编号、右孩子结点编号。设结点从0~(N-1)顺序编号。若某结点不存在孩子结点，则该位置给出−1。
输出格式:

输出YES如果该树是一棵笛卡尔树；否则输出NO。
输入样例1:

6
8 27 5 1
9 40 -1 -1
10 20 0 3
12 21 -1 4
15 22 -1 -1
5 35 -1 -1

输出样例1:

YES

输入样例2:

6
8 27 5 1
9 40 -1 -1
10 20 0 3
12 11 -1 4
15 22 -1 -1
50 35 -1 -1

输出样例2:

NO

思路
无非就是用两种遍历方式分别验证每个结点的K1值和K2值是否分别符合规则。

点击访问 PTA-测验

#include <stdio.h>
#include<stdlib.h>
#define ERRORMin 99999//'这个地方其实是有一定风险，因为题目并没有指出K值的上界'
#define ERRORMax -99999//同上
/* 评测结果 时间  结果  得分  题目  编译器     用时（ms）  内存（MB）  用户
2016-08-30 11:05    正在评测    0   5-31    gcc     无   无   569985011
测试点结果 测试点   结果  得分/满分   用时（ms）  内存（MB）
测试点1    答案正确    6/6     1   1
测试点2    答案正确    6/6     2   1
测试点3    答案正确    3/3     1   1
测试点4    答案正确    3/3     3   1
测试点5    答案正确    3/3     2   1
测试点6    答案正确    2/2     2   1
测试点7    答案正确    2/2     1   1
查看代码*/
typedef struct node *Node;
struct node {
    int K1;
    int Max_K1,Min_K1;
    int K2;
    int Left;
    int Right;
}*Decare;

int n;
int Root();
int DLR(int);//前序，Degree Left Right
int LRD(int);//后序，Left Right Degree

int main() {

    scanf("%d",&n);
    Decare=(Node)malloc(sizeof(struct node)*n);
    for(int i=0; i<n; i++) {
        scanf("%d",&Decare[i].K1);
        scanf("%d",&Decare[i].K2);
        scanf("%d",&Decare[i].Left);
        scanf("%d",&Decare[i].Right);
        Decare[i].Min_K1=ERRORMin;
        Decare[i].Max_K1=ERRORMax;
    }
    int head=Root();
    int Result =DLR(head);
    if(Result)Result=LRD(head);
    if(Result)printf("YES\n");
    else printf("NO\n");

    return 0;
}

int Root() {
    int*temp=(int*)malloc(sizeof(int)*n);
    for(int i=0; i<n; i++) {
        temp[i]=0;
    }
    for(int i=0; i<n; i++) {
        temp[Decare[i].Left]=1;
        temp[Decare[i].Right]=1;
    }
    for(int i=0; i<n; i++) {
        if(!temp[i])return i;
    }
    return -1;//没有根节点
}
int DLR(int K) { //K2判定
    if(K==-1)return 1;

    if(Decare[K].Left!=-1)
        if(Decare[Decare[K].Left].K2<Decare[K].K2)return 0;
    if(Decare[K].Right!=-1)
        if(Decare[Decare[K].Right].K2<Decare[K].K2)return 0;

    if( DLR(Decare[K].Left)==0)return 0;

    if(DLR(Decare[K].Right)==0)return 0;
    return 1;
}
int LRD(int K) {//K1判定,先把Min_K1 Max_K1计算出来在比较
    if(K==-1)return 1;

    if(LRD(Decare[K].Left)==0)return 0;
    if(Decare[K].Left==-1)Decare[K].Min_K1=Decare[K].K1;
    else Decare[K].Min_K1=Decare[Decare[K].Left].Min_K1;

    if(LRD(Decare[K].Right)==0)return 0;
    if(Decare[K].Right==-1)Decare[K].Max_K1=Decare[K].K1;
    else Decare[K].Max_K1=Decare[Decare[K].Right].Max_K1;

    int temp=K;
    if(Decare[temp].Left!=-1)
    if(Decare[temp].K1<Decare[Decare[temp].Left].Max_K1)return 0;
    if(Decare[temp].Right!=-1)
    if(Decare[temp].K1>Decare[Decare[temp].Right].Min_K1)return 0;

    return 1;
}