PAT-A1135 Is It A Red-Black Tree 题目内容及题解

There is a kind of balanced binary search tree named red-black tree in the data structure. It has the following 5 properties:

• (1) Every node is either red or black.
• (2) The root is black.
• (3) Every leaf (NULL) is black.
• (4) If a node is red, then both its children are black.
• (5) For each node, all simple paths from the node to descendant leaves contain the same number of black nodes.

For example, the tree in Figure 1 is a red-black tree, while the ones in Figure 2 and 3 are not.

For each given binary search tree, you are supposed to tell if it is a legal red-black tree.

Input Specification:

Each input file contains several test cases. The first line gives a positive integer K (≤30) which is the total number of cases. For each case, the first line gives a positive integer N (≤30), the total number of nodes in the binary tree. The second line gives the preorder traversal sequence of the tree. While all the keys in a tree are positive integers, we use negative signs to represent red nodes. All the numbers in a line are separated by a space. The sample input cases correspond to the trees shown in Figure 1, 2 and 3.

Output Specification:

For each test case, print in a line "Yes" if the given tree is a red-black tree, or "No" if not.

Sample Input:

3
9
7 -2 1 5 -4 -11 8 14 -15
9
11 -2 1 -7 5 -4 8 14 -15
8
10 -7 5 -6 8 15 -11 17

Sample Output:

Yes
No
No

题目大意

题目给出若干二叉平衡树的前序遍历，要求检验并输出其是否为合法的红黑树。

解题思路

1. 对每个测试样例先初始化并读入数据；
2. 用前序遍历的顺序作为插入顺序建立二叉树；
3. 对该二叉树通过前序遍历查看其是否每个节点都符合特征；
4. 对该二叉树通过后序遍历查看从根节点到叶子节点是否黑色节点数相等；
5. 输出结果；
6. 所有循环完成后返回零值。

代码

#include<cstdio>
#include<cmath>
int Max(int a,int b){
    return a>b?a:b;
}

int Abs(int a){
    return a>0?a:-a;
}

struct Node{
    int v;
    int Black;
    Node *lchild,*rchild;
};

void Insert(Node* &root,int v){
    if(root==NULL){
        root=new(Node);
        if(v>0){
            root->v=v;
            root->Black=1;
        }else{
            root->v=-v;
            root->Black=0;
        }
        root->lchild=NULL;
        root->rchild=NULL;
        return;
    }
    if(Abs(v)<root->v){
        Insert(root->lchild,v);
    }else{
        Insert(root->rchild,v);
    }
}

bool PreOrder(Node* root){
    if(root==NULL){
        return true;
    }
    if(root->Black==0){
        if(root->lchild!=NULL&&root->lchild->Black==0){
            return false;
        }
        if(root->rchild!=NULL&&root->rchild->Black==0){
            return false;
        }
    }
    return PreOrder(root->lchild)&&PreOrder(root->rchild);
}
int Getnum(Node* root){
    if(root==NULL){
        return 0;
    }
    int lnum=Getnum(root->lchild);
    int rnum=Getnum(root->rchild);
    return Max(lnum,rnum)+root->Black;
}

bool Check(Node* root){
    bool tmp;
    if(root==NULL){
        return true;
    }
    int l=Getnum(root->lchild);
    int r=Getnum(root->rchild);
    if(l==r){
        tmp=Check(root->lchild)&&Check(root->rchild);
        return tmp;
    }else{
        return false;
    }
}

int main(){
    int K,N,a;
    Node* root;
    scanf("%d",&K);
    while(K--){
        root=NULL;
        scanf("%d",&N);
        while(N--){
            scanf("%d",&a);
            Insert(root,a);
        }
        if(root->Black&&PreOrder(root)&&Check(root)){
            printf("Yes\n");
        }else{
            printf("No\n");
        }
    }
    return 0;
}

运行结果