二叉树的复原--编号复原

二叉树的复原

最近写到一些题目，类型为：

给出一些节点加左，右孩子的节点编号，要求复原该二叉树，然后输出一些要求的东西。

例题1：

对于给定的二叉树，本题要求你按从上到下、从左到右的顺序输出其所有叶节点。

输入格式：
首先第一行给出一个正整数 N（≤10），为树中结点总数。树中的结点从 0 到 N−1 编号。随后 N 行，每行给出一个对应结点左右孩子的编号。如果某个孩子不存在，则在对应位置给出 “-”。编号间以 1 个空格分隔。

输出格式：
在一行中按规定顺序输出叶节点的编号。编号间以 1 个空格分隔，行首尾不得有多余空格。

输入样例：

8
1 -

0 -
2 7

5 -
4 6

输出样例：

4 1 5

思路：先找到输入样例中没有出现过的编号，作为树的根，再根据该节点的左右儿子串联起整棵树

代码:

#include<stdio.h>
#include<malloc.h>
#define N 15
struct TNode {
    int data;
    struct TNode* Left;
    struct TNode* Right;
}Tree[N];//构造足量的树

//全局变量//
int zb[N] = { 0 };//寻找叶节点的数组
int d = 0;//记录叶节点个数和下标

//功能函数//
void yezhi(struct TNode* bt, int n);//寻找叶节点并且将叶节点存入全局数组zb中

//主函数//
int main()
{
    int n;
    scanf("%d\n", &n);
    char a, b;
    int k[n] = { 0 };//记录被标注的节点和寻找未标注的节点
    int i = 0;
    while (i < n) {
        scanf("%c %c\n", &a, &b);
        if (a != '-') {
            Tree[i].Left = &Tree[a - '0'];
            k[a - '0']++;
        }
        else {
            Tree[i].Left = NULL;
        }
        if (b != '-') {
            Tree[i].Right = &Tree[b - '0'];
            k[b - '0']++;
        }
        else {
            Tree[i].Right = NULL;
        }
        Tree[i].data=i;
        i++;
    }
    for (i = 0; i < n; i++) {//遍历寻找未被标志的节点为树的根
        if (k[i] == 0) {
            break;
        }
    }
    yezhi(&Tree[i], n);
    if (d != 0) {
        printf("%d", zb[0]);
        for (i = 1; i < d; i++) {
            printf(" %d", zb[i]);
        }
    }
}
void yezhi(struct TNode* bt, int n)//通过层序遍历，将树放在q的结构数组中，再在数组中寻在叶节点，将叶节点存在zb数组中
{
    struct TNode* q[N];
    int real = 0, front = 0;
    if (bt) {
        q[real++] = bt;
        while (real != front) {
            struct TNode* t;
            t = q[front++];
            if (t->Left) {
                q[real++] = t->Left;
            }
            if (t->Right) {
                q[real++] = t->Right;
            }
        }
    }
    int i = 0;
    for (i = 0; i < n; i++) {
        if (q[i]->Left == NULL && q[i]->Right == NULL) {
            zb[d++] = q[i]->data;//将叶节点记录下来
        }
    }
}

例题：

4-2-3 二叉搜索树／堆 笛卡尔树 (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

思路：这俩题在复原树的过程思路是一样的，这题难一些，涉及到笛卡尔树的检测，要判断是否为搜索树
代码：

#include<stdio.h>
#include<malloc.h>
#define N 1005
struct TNode {
    int k1;
    int k2;
    struct TNode* Left;
    struct TNode* Right;
}T[N];//构造一定量的树
typedef struct TNode* Tree;


//全局变量//
int zb[N] = { 0 };//存T->k1的中序遍历的数组
int flag1 = 1;//判断是否为搜索树的标志
int flag2 = 1;//判断是否符合k2的要求
int d=0;//给zb数组做下标

void judge1(int *zb,int n);//判断k1
void judge2(Tree T);//判断k2
void ino(Tree T);//中序遍历
int main()
{
    int n;
    scanf("%d", &n);
    int k[N] = { 0 };//该数组用来寻找树的根节点
    int i = 0;
    int a1, a2, l, r;//记录k1,k1,Left,Right
    for (i = 0; i < n; i++) {
        scanf("%d %d %d %d", &a1, &a2, &l, &r);
        T[i].k1 = a1;
        T[i].k2 = a2;
        if (l == -1) {
            T[i].Left = NULL;
        }
        else {
            T[i].Left = &T[l];
            k[l]++;
        }
        if (r == -1) {
            T[i].Right = NULL;
        }
        else {
            T[i].Right = &T[r];
            k[r]++;
        }
    }
    for (i = 0; i < n; i++) {//寻找未被指向的节点的下标，T[i]
        if (k[i] == 0) {
            break;
        }
    }
    ino(&T[i]);
    judge1(zb,n);
    judge2(&T[i]);
    if (flag1 == 1 && flag2 == 1) {
        printf("YES\n");
    }
    else {
        printf("NO\n");
    }
    return 0;
}
void ino(Tree T)
{
    if(T){
        ino(T->Left);
        zb[d++]=T->k1;
        ino(T->Right);
    }
}
void judge1(int* zb,int n)//因为是搜索树，所以该树的中序遍历未递增数列
{
    int i=0;
    for(i=0;i<n-1;i++){
        if(zb[i]>=zb[i+1]){
            flag1=0;
        }
    }
}
void judge2(Tree T)
{
    if (T) {
        if (T->Left != NULL || T->Right != NULL) {
            judge2(T->Left);
            if (T->Left != NULL && T->k2 > T->Left->k2) {//左儿子的k2要大于他
                flag2 = 0;
            }
            if (T->Right != NULL && T->k2 > T->Right->k2) {//右儿子的k2要大于他
                flag2 = 0;
            }
            judge2(T->Right);
        }
    }
}

总结：

在解决这种复原树的过程，需要的几个关键代码块
1.数组结构

struct TNode {
    int data;
    struct TNode* Left;
    struct TNode* Right;
}Tree[N];//构造足量的树

struct TNode {
    int k1;
    int k2;
    struct TNode* Left;
    struct TNode* Right;
}T[N];//构造一定量的树

通过数组结构直接将题目的数据链接成树
2.复原和遍历找树根下标

    for (i = 0; i < n; i++) {
        scanf("%d %d %d %d", &a1, &a2, &l, &r);
        T[i].k1 = a1;
        T[i].k2 = a2;
        if (l == -1) {
            T[i].Left = NULL;
        }
        else {
            T[i].Left = &T[l];
            k[l]++;
        }
        if (r == -1) {
            T[i].Right = NULL;
        }
        else {
            T[i].Right = &T[r];
            k[r]++;
        }
    }
    for (i = 0; i < n; i++) {//寻找未被指向的节点的下标，T[i]
        if (k[i] == 0) {
            break;
        }
    }

    for (i = 0; i < n; i++) {
        scanf("%d %d %d %d", &a1, &a2, &l, &r);
        T[i].k1 = a1;
        T[i].k2 = a2;
        if (l == -1) {
            T[i].Left = NULL;
        }
        else {
            T[i].Left = &T[l];
            k[l]++;
        }
        if (r == -1) {
            T[i].Right = NULL;
        }
        else {
            T[i].Right = &T[r];
            k[r]++;
        }
    }
    for (i = 0; i < n; i++) {//寻找未被指向的节点的下标，T[i]
        if (k[i] == 0) {
            break;
        }
    }

利用读入数据的循环中将树构建起来，利用与编号相同的数组下标寻找树的根节点，用于后序的函数调用