【笨方法学PAT】1064 Complete 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.

A Complete Binary Tree (CBT) is a tree that is completely filled, with the possible exception of the bottom level, which is filled from left to right.

Now given a sequence of distinct non-negative integer keys, a unique BST can be constructed if it is required that the tree must also be a CBT. You are supposed to output the level order traversal sequence of this BST.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (≤1000). Then N distinct non-negative integer keys are given in the next line. All the numbers in a line are separated by a space and are no greater than 2000.

Output Specification:

For each test case, print in one line the level order traversal sequence of the corresponding complete binary search tree. All the numbers in a line must be separated by a space, and there must be no extra space at the end of the line.

Sample Input:

10
1 2 3 4 5 6 7 8 9 0

Sample Output:

6 3 8 1 5 7 9 0 2 4

二、题目大意

给一串构成树的序列，已知该树是完全二叉搜索树，求它的层序遍历的序列。

三、考点

BST

四、注意

1、https://blog.csdn.net/xyt8023y/article/details/47177853。

五、主流代码

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
vector<int> in;
vector<int> tree;
int n;
int index = 1;
void inOrder(int root) {
	if (root > n)
		return;
	inOrder(root * 2);
	tree[root] = in[index++];
	inOrder(root * 2 + 1);
	return;
}
int main() {
	//read
	cin >> n;
	in.resize(n+1), tree.resize(n+1);
	for (int i = 1; i <= n; ++i)
		cin >> in[i];

	//sort
	sort(in.begin(), in.end());

	inOrder(1);

	for (int i = 1; i <= n; ++i) {
		if (i != 1)
			cout << " ";
		cout << tree[i];
	}

	system("pause");
	return 0;
}

六、笨方法

1、利用完全二叉树（CBT）2*i, 2*i+1（根据i的不同，也看是2*i+1，2*i+2），使用vector<struct node>保存树的结构；

2、对输入从小到大排序，获得中序遍历；

3、根据中序遍历，反向求得树节点的数据；

4、使用queue得到层次遍历。

七、笨方法代码

#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
int n;
struct node {
	int val;
	int left=-1, right=-1;
};
vector<node> tree;
vector<int> in,level;
int index = 0;

void dfs(int root) {
	if (root >= n)
		return;
	if(tree[root].left!=-1)
		dfs(tree[root].left);
	tree[root].val = in[index++];
	if(tree[root].right!=-1)
		dfs(tree[root].right);
	return;
}
int main() {
	//read
	cin >> n;
	tree.resize(n);

	//build tree
	for (int i = 0; i < n; ++i) {
		if (2 * i + 1 < n)
			tree[i].left = 2 * i + 1;
		if (2 * i + 2 < n)
			tree[i].right = 2 * i + 2;
	}

	in.resize(n);
	for (int i = 0; i < n; ++i)
		cin >> in[i];

	//sort
	sort(in.begin(), in.end());

	//dfs
	dfs(0);

	//level
	queue<int> que;
	que.push(0);
	while (!que.empty()) {
		int root = que.front();
		level.push_back(tree[root].val);
		que.pop();
		if (tree[root].left != -1)
			que.push(tree[root].left);
		if (tree[root].right != -1)
			que.push(tree[root].right);
	}

	//output
	for (int i = 0; i < n; ++i) {
		if (i != 0)
			cout << " ";
		cout << level[i];
	}

	system("pause");
	return 0;
}