DS实验题 地鼠安家

★实验任务

fd是一个公认的美丽校园。一天，fd来了一群地鼠,编号为1到n，他们希望在这里定居。现在先由第一只地鼠往下打一个单位的距离，并且在那里安家。对于每一个已经安家的地鼠，如果他左下或右下没有邻居，那还没安家的地鼠就可以在他的左下或者右下安家。地鼠们已经建完所有的窝了，他们评价这些窝合格的标准是它们能不能形成一棵二叉搜索树（二叉搜索树的定义见课本）。现在需要你帮助他们评估一下他们的窝挖的是否合格。

★数据输入

第1行一个整数n，表示地鼠总共n只。接下来一共n行，每一行三个数：l,o,r，其中l表示编号为o的地鼠的左邻居的编号，r表示的是编号为o的右邻居的编号，如果没有左邻居或右邻居，则l或r为-1。1<=n<=10000。保证给出的是一颗二叉树。

★数据输出

输出一行，如果如果他们的窝合格，则输出安居在最深的窝的地鼠离地面的距离，如果不合格，则输出-1。

输入示例

5
-1 1 -1
1 2 3
-1 3 -1
2 4 5
-1 5 -1

输出示例

3

代码实现

//
//  main.cpp
//  地鼠打洞
//
//  Created by wasdns on 16/10/26.
//  Copyright © 2016年 wasdns. All rights reserved.
//

#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <string>
#include <stack>
using namespace std;

#define fMax -10000;

struct Tree {
    Tree *l;
    Tree *r;
    int num;
    int lnum;
    int rnum;
    int flag;
}s[10005];

/*
Tree* IniNode() {
    Tree *p;
 
    p = new Tree;
    if (p == NULL) {
        cout << "Error" << endl;
        exit(1);
    }
 
    return p;
}
 */

Tree* CreatTree(int n) {
    
    int i, j;
    
    int lturn, rturn;
    for (i = 0; i < n; i++) {
        
        lturn = s[i].lnum;
        rturn = s[i].rnum;
        
        if (lturn == -1 && rturn == -1) continue;
        
        else {
            
            if (lturn != -1 && rturn == -1) {
                
                for (j = 0; j < n; j++) {
                    
                    if (s[j].num == lturn) {
                        s[i].l = &s[j];
                        s[j].flag = 1;
                        break;
                    }
                }
            }
            
            else if (lturn == -1 && rturn != -1) {
                
                for (j = 0; j < n; j++) {
                    
                    if (s[j].num == rturn) {
                        s[i].r = &s[j];
                        s[j].flag = 1;
                        break;
                    }
                }
            }
            
            else {
                
                for (j = 0; j < n; j++) {
                    
                    if (s[j].num == lturn) {
                        s[i].l = &s[j];
                        s[j].flag = 1;
                    }
                    
                    if (s[j].num == rturn) {
                        s[i].r = &s[j];
                        s[j].flag = 1;
                    }
                }
            }
        }
    }
    
    Tree *header;
    for (i = 0; i < n; i++) {
        
        if (s[i].flag == 0) {
            header = &s[i];
            break;
        }
    }
    
    return header;
}

int t = fMax;

bool TreeJudge(Tree *p) {
    
    bool jr = true;
    
    if (p != NULL) {
        
        bool j1 = TreeJudge(p -> l);
        
        if (!j1) {
            jr = false;
            return jr;
        }
        
        
        if (p -> num < t) {
            jr = false;
            return jr;
        }
        else {
            t = p -> num;
        }
        
        
        bool j2 = TreeJudge(p -> r);
        
        if (!j2) {
            jr = false;
            return jr;
        }
    }
    
    return jr;
}

int TreeHeight(Tree* header) {
    
    int lheight = 0;
    int rheight = 0;
    
    if (!header) return 0;
    else {
        
        lheight = TreeHeight(header -> l);
        rheight = TreeHeight(header -> r);
        
        if (lheight > rheight) {
            return lheight + 1;
        }
        else {
            return rheight + 1;
        }
    }
    
    return 0;
}


int main() {
    int n;
    int i;
    
    cin >> n;
    
    for (i = 0; i < n; i++) {
        cin >> s[i].lnum >> s[i].num >> s[i].rnum;
        s[i].l = NULL;
        s[i].r = NULL;
        s[i].flag = 0;
    }
    
    Tree *header;
    header = CreatTree(n);
    
    if (!TreeJudge(header)) {
        cout << "-1" << endl;
    }
    else {
        cout << TreeHeight(header) << endl;
    }
    
    return 0;
}

2016/10/30