数据结构PTA习题：进阶实验4-3.4 笛卡尔树 (25分)

进阶实验4-3.4 笛卡尔树 (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的二叉搜索树：
左子树满足二叉搜索树，右子树满足二叉搜索树，左子树的最大K1值小于根结点的K1值，右子树的最小K1值大于根结点的K1值。

其次所有结点的K2关键字满足优先队列的顺序要求：
左子树满足优先队列的顺序要求，右子树满足优先队列的顺序要求，且根结点的K2值比左子树根结点的K2值和右子树根结点的K2值都小。

C语言实现：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct node
{
 int K1;//K1关键字
 int K2;//K2关键字
 int left;//左孩子下标
 int right;//右孩子下标
};
typedef struct node * Bintree;
int JudgeK1(int n);//判断是否是关于K1的二叉搜索树
int JudgeK2(int n);//判断所有结点的K2关键字是否满足优先队列的顺序要求
Bintree B;//结构体数组B
int main()
{
 int N;
 scanf("%d", &N);
 if (N == 1) { printf("YES\n"); }
 else
 {
  B = (Bintree)malloc(N * sizeof(struct node));
  int i; int root;
  //用数组t寻找根结点。出现过的下标i对应的t[i]设为1，最后t[j]==0的下标对应根结点
  int * t;
  t = (int *)malloc(N * sizeof(int));
  for (i = 0; i < N; i++)
  {
   t[i] = 0;
  }
  for (i = 0; i < N; i++)
  {
   scanf("%d %d %d %d", &(B[i].K1), &(B[i].K2), &(B[i].left), &(B[i].right));
   if (B[i].left != -1) { t[B[i].left] = 1; }
   if (B[i].right != -1) { t[B[i].right] = 1; }
  }
  for (i = 0; i < N; i++)
  {
   if (t[i] == 0) { break; }
  }
  root = i;
  int ret1 = JudgeK1(root);
  int ret2 = JudgeK2(root);
  if (ret1 == 1 && ret2 == 1)
  {
   printf("YES\n");
  }
  else
  {
   printf("NO\n");
  }
 }
 return 0;
}
//判断是否是关于K1的二叉搜索树，迭代
//输入参数为根结点下标
int JudgeK1(int n)
{
 int leftmax=-100000, rightmin=100000;
 if (n == -1) { return 1; }
 else
 {
  int ret1, ret2;
  ret1 = JudgeK1(B[n].left);//判断左子树
  ret2 = JudgeK1(B[n].right);//判断右子树
  int index;
  //寻找左子树的最大K1值leftmax
  index = B[n].left;
  if (index != -1)
  {
   while (B[index].right != -1)
   {
    index = B[index].right;
   }
   leftmax = B[index].K1;
  }
  //寻找右子树的最小K1值rightmin
  index = B[n].right;
  if (index != -1)
  {
   while (B[index].left != -1)
   {
    index = B[index].left;
   }
   rightmin = B[index].K1;
  }
  if (ret1&&ret2&&leftmax < B[n].K1&&B[n].K1 < rightmin) { return 1; }
  else { return 0; }
 }
}
//判断所有结点的K2关键字是否满足优先队列的顺序要求，迭代
//输入参数为根结点下标
int JudgeK2(int n)
{
 if (n == -1) { return 1; }
 else
 {
  int ret1, ret2;
  ret1 = JudgeK2(B[n].left);//判断左子树
  ret2 = JudgeK2(B[n].right);//判断右子树
  //且根结点的K2值比左子树根结点的K2值和右子树根结点的K2值都小
  if (B[n].left != -1 && B[n].right != -1)
  {
   if (ret1&&ret2&&B[B[n].left].K2 > B[n].K2&&B[B[n].right].K2 > B[n].K2) { return 1; }
   else { return 0; }
  }
  else if (B[n].left != -1)
  {
   if (ret1&&ret2&&B[B[n].left].K2 > B[n].K2) { return 1; }
   else { return 0; }
  }
  else if (B[n].right != -1)
  {
   if (ret1&&ret2&B[B[n].right].K2 > B[n].K2) { return 1; }
   else { return 0; }
  }
  else
  {
   if (ret1&&ret2) { return 1; }
   else { return 0; }
  }
 }
}