1099 Build A Binary Search Tree (30分)(BST的层序或者中序遍历建树，层序便利输出树)

1099 Build A Binary Search Tree (30分)

 

A Binary Search Tree (BST) is recursively defined as a binary tree which has the following properties:

• The left subtree of a node contains only nodes with keys less than the node's key.
• The right subtree of a node contains only nodes with keys greater than or equal to the node's key.
• Both the left and right subtrees must also be binary search trees.

Given the structure of a binary tree and a sequence of distinct integer keys, there is only one way to fill these keys into the tree so that the resulting tree satisfies the definition of a BST. You are supposed to output the level order traversal sequence of that tree. The sample is illustrated by Figure 1 and 2.

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (≤) which is the total number of nodes in the tree. The next N lines each contains the left and the right children of a node in the format left_index right_index, provided that the nodes are numbered from 0 to N−1, and 0 is always the root. If one child is missing, then − will represent the NULL child pointer. Finally N distinct integer keys are given in the last line.

Output Specification:

For each test case, print in one line the level order traversal sequence of that tree. All the numbers must be separated by a space, with no extra space at the end of the line.

Sample Input:

9
1 6
2 3
-1 -1
-1 4
5 -1
-1 -1
7 -1
-1 8
-1 -1
73 45 11 58 82 25 67 38 42

 

Sample Output:

58 25 82 11 38 67 45 73 42

这题我一开始的思路是先按照给出的节点数据层序遍历建树，这次建树是为了固定BST每个节点的位置。由于BST的中序遍历就是
元素值的排序，因此我们将读入的值排序，然后中序遍历之前固定位置用的那棵树，再将值一一插入。最后层序输出。

层序遍历的代码上面有个需要注意的地方。如果你要将一个节点加入队列，那你必将先为这个节点开辟空间再将其加入，坚决不
能先加入队列，然后再分配空间。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

struct Tree {
    int data;
    Tree *l, *r;
} *root;
typedef Tree* ptree;

int n, lc, rc;

vector <int> ans;

typedef pair <int, int> pii;

pii vec[100 + 5];

void level(ptree &root) {
    queue <ptree> que;
    root = new Tree;
    root -> data = 0;
    root -> l = root -> r = NULL;
    que.push(root);
    while(!que.empty()) {
        ptree now = que.front(), temp;
        int k = now -> data;
        que.pop();
        lc = vec[k].first, rc = vec[k].second;
        if(~lc) {
            temp = new Tree;
            temp -> data = lc;
            temp -> l = temp -> r = NULL;
            now -> l = temp;
            que.push(temp);
        }
        if(~rc) {
            temp = new Tree;
            temp -> data = rc;
            temp -> l = temp -> r = NULL;
            now -> r = temp;
            que.push(temp);
        }
    }
}

int val[100 + 5];

int cnt;

void inorder(ptree &root) {
    if(root == NULL) {
        return;
    }
    inorder(root -> l);
    root -> data = val[cnt ++];
    inorder(root -> r);
}

void levelorder(ptree root) {
    if(root == NULL) return;
    queue <ptree> que;
    que.push(root);
    while(!que.empty()) {
        ptree now = que.front();
        que.pop();
        ans.push_back(now -> data);
        if(now -> l) que.push(now -> l);
        if(now -> r) que.push(now -> r);
    }
}

int main() {
    scanf("%d", &n);
    for(int i = 0; i < n; i ++) {
        scanf("%d %d", &lc, &rc);
        vec[i] = make_pair(lc, rc);
    }
    level(root);
    for(int i = 0; i < n; i ++) {
        scanf("%d", &val[i]);
    }
    sort(val, val + n);
    inorder(root);
    levelorder(root);
    for(int i = 0; i < ans.size(); i ++) {
        if(i) printf(" ");
        printf("%d", ans[i]);
    }
    printf("
");
    return 0;
}

是的，上面的是我这种蠢人的做法。。。
AC了之后看到别人直接中序遍历建树，我吐了。
为什么是直接中序遍历建树呢？

我们一开始读入了从0 ~ n所有节点的左右儿子的idx。
然后如果我们用刚刚读入的数据从idx[0]直接开始中序遍历建树，因为如果中序遍历建树，那么我们就可以直接在访问到一个节点的
时候把值赋给他。因此并不需要先层序遍历确定树的结构，因为你中序建树用的也是这些节点，你建的树模子和层序建的树一模一样
，因此你只需要在中序建树的时候顺便把相应的值赋给他就ok了。代码就不实现了吧。直接递归建，数据小。