1064 Complete Binary Search Tree (30分)

思路一

通过观察发现，对于既是BST又是CST的树，它的任意一个结点存在三种情况：

1. 左子树是满二叉树，但右子树不是满二叉树
2. 左子树不是满二叉树，但右子树是满二叉树
3. 左右子树都是满二叉树

可见，不会出现左右子树都不是满二叉树的情况。同时，由完全二叉树的定义可知：对于树的某个位置，它的左子树的结点数>=右子树的结点数。
通过对给出的序列排序，我们得到中序序列。我们可以从中序序列的中间开始向右逐个扫描，当某个结点符合以上三种情况之一时就可以确定当前位置应该放置该结点。

#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<cmath>
using namespace std;
vector<int> keys;
struct node {
	int val;
	node *left, *right;
	node(int v) {
		val = v;
		left = NULL;
		right = NULL;
	}
}*root;
//具有n层的满二叉树的结点数为2^n-1，用结点数反算层数n，当得到n为整数时说明用给定的结点数可以构成满二叉树
bool isFull(int size) {	//whether the given size can make a full binary tree
	double n = log(size + 1) / log(2);
	return n == (int)n;
}
//这个解法的核心函数，从给定的范围确定哪个结点是子树的根
int getRootIndex(int left, int right) {	//get the index of root from the given range
	int mid = (left + right + 1) / 2;
	while (true) {
		int leftSize = mid - left, rightSize = right - mid;
		if (isFull(leftSize) || isFull(rightSize)) {
			return mid;
		}
		else mid++;
	}
}
void buildTree(node *&cur, int left, int right) {	//build the tree recursively
	if (left > right) {
		return;
	}
	int index = getRootIndex(left, right);
	cur = new node(keys[index]);
	buildTree(cur->left, left, index - 1);
	buildTree(cur->right, index + 1, right);
}
int main() {
	int n;
	cin >> n;
	keys.resize(n);
	for (int i = 0; i < n; i++) {
		cin >> keys[i];
	}
	sort(keys.begin(), keys.end());
	buildTree(root, 0, n - 1);
	queue<node*> q;
	vector<int> levelOrder;
	q.push(root);
	while (!q.empty()) {
		node* temp = q.front();
		q.pop();
		levelOrder.push_back(temp->val);
		if (temp->left != NULL) {
			q.push(temp->left);
		}
		if (temp->right != NULL) {
			q.push(temp->right);
		}
	}
	for (int i = 0; i < levelOrder.size(); i++) {
		if (i != 0)
			cout << " ";
		cout << levelOrder[i];
	}
}

思路二

1. 通过排序得到树的中序序列
2. 对于层序遍历，当树的下标从0开始时，则如果一个结点下标为i，则它的左子结点下标为2 * i + 1，右子结点为2 * i + 2
3. 按照中序遍历的遍历顺序往层序遍历数组levelorder中填入值。即通过递归，先填左子树levelorder[2 * i + 1]，再填根节点levelorder[i]，最后填右子树levelorder[2 * i + 2]。

#include <iostream>
#include <algorithm>
#include<vector>
using namespace std;
int n;
vector<int> inorder, levelorder;
int index = 0;
//将中序序列的值递归放到层序数组中
void putInLevelOrder(int root) {
	if (root >= n) return;
	putInLevelOrder(root * 2 + 1);
	levelorder[root] = inorder[index++];
	putInLevelOrder(root * 2 + 2);
}
int main() {
	scanf("%d", &n);
	inorder.resize(n);
	levelorder.resize(n);
	for (int i = 0; i < n; i++)
		scanf("%d", &inorder[i]);
	sort(inorder.begin(), inorder.end());
	putInLevelOrder(0);
	for (int i = 0; i < n; i++) {
		if (i != 0)
			printf(" ");
		printf("%d", levelorder[i]);
	}
}