前言
学习数据结构,记录下过程
一、原题
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
结尾无空行
简单翻译一下就是构建一个完全二叉树(高度最小,叶节点也是从左到右),最后还要满足满足二叉搜索树,就是左小右大。
可以看到题目就是给十个数,先自己排序,然后按照中序遍历方式填充,就可以得到满足条件的二叉搜索树了,因为中序遍历是左中右嘛,从小到大排好序的数组按照左中右的顺序往完全二叉树里面填,就是题目要求的CBT了,最后层次遍历输出,就是正确结果了。
二、方法
1.常规构建二叉搜索树
刚开始就直接按照常见的二叉树的思路写的,把之前写的二叉树相关的代码裁剪一下(偷个懒),思路是先开一个固定空间的完全二叉树,然后中序遍历往里面填充,最后层序遍历输出。
开CBT空间其实就是层序遍历,得从上到下,从左到右,层序遍历是利用一个队列实现按顺序插入数据,咱这个不用插入数据,就直接一个int size计数就可以了。
template<typename T>
void BinaryTree<T>::Create(const int & size)
{
int count = size;
queue<BinTreeNode<T>*> Q;
BinTreeNode<T>* t = new BinTreeNode<T>;
Q.push(t);
if (root != NULL)
clear();
root = t;
for (int i = 1; i < count; i++)
{
t = Q.front();
if (t->leftChild == NULL)
{
t->leftChild = new BinTreeNode<T>;
Q.push(t->leftChild);
}
else
{
t->rightChild = new BinTreeNode<T>;
Q.push(t->rightChild);
Q.pop();
}
}
}
中序遍历填充就是在刚刚开辟的空间上遍历,并把队列里的数添加至结点上,代码也是基于中序遍历稍做修改。
最后层序遍历也是老生常谈的函数了。
代码如下(示例):
#include <iostream>
#include <algorithm>
#include <stack>
#include <queue>
#include <string>
using namespace std;
template <typename T>
class BinTreeNode
{
typedef T DataType;
public:
BinTreeNode() { leftChild = NULL; rightChild = NULL; }
BinTreeNode(T d, BinTreeNode<T> *l, BinTreeNode<T> *r) :data(d), leftChild(l), rightChild(r) {}
BinTreeNode(BinTreeNode<T> *l, BinTreeNode<T> *r) : leftChild(l), rightChild(r) {}
T data;
BinTreeNode<T>* leftChild;
BinTreeNode<T>* rightChild;
int height;
};
template <typename T>
class BinaryTree
{
typedef T DataType;
protected:
BinTreeNode<T>* root;
private:
void Destroy(BinTreeNode<T>* current);
void Create_InOrder(queue<T> &Q, BinTreeNode<T>* cur);
void LevelOrder(BinTreeNode<T>* current);//按层次遍历
public:
BinaryTree() { root = NULL; }
void clear() { Destroy(root); root = NULL; }//删除二叉树
DataType Root() { return root->data; }//返回根节点数据
void Create(const int& size);//建立结点个数为size的CBT
void Create(queue<T> Q);
void LevelOrder();//按层次遍历
bool isEmpty() { return root == NULL; }//二叉树是否为空
};
template<typename T>
void BinaryTree<T>::Destroy(BinTreeNode<T>* current)
{
if (current == NULL)
return;
Destroy(current->leftChild);
Destroy(current->rightChild);
delete current;
}
template<typename T>
void BinaryTree<T>::Create(queue<T> Q)
{
Create(Q.size());
Create_InOrder(Q, root);
}
template<typename T>
void BinaryTree<T>::Create(const int & size)
{
int count = size;
queue<BinTreeNode<T>*> Q;
BinTreeNode<T>* t = new BinTreeNode<T>;
Q.push(t);
if (root != NULL)
clear();
root = t;
for (int i = 1; i < count; i++)
{
t = Q.front();
if (t->leftChild == NULL)
{
t->leftChild = new BinTreeNode<T>;
Q.push(t->leftChild);
}
else
{
t->rightChild = new BinTreeNode<T>;
Q.push(t->rightChild);
Q.pop();
}
}
}
template<typename T>
void BinaryTree<T>::Create_InOrder(queue<T> &Q, BinTreeNode<T>* cur)
{
if (cur != NULL)
{
Create_InOrder(Q, cur->leftChild);
cur->data = Q.front();
Q.pop();
Create_InOrder(Q, cur->rightChild);
}
}
template<typename T>
void BinaryTree<T>::LevelOrder()
{
LevelOrder(root);
}
template<typename T>
void BinaryTree<T>::LevelOrder(BinTreeNode<T>* current)
{
queue<BinTreeNode<T>*> Q;
Q.push(current);
int first = 1;
while (!Q.empty())
{
current = Q.front();//出队
Q.pop();
if (first == 1)
{
first = 0;
}
else
{
cout << " ";
}
cout << current->data;
if (current->leftChild)
Q.push(current->leftChild);
if (current->rightChild)
Q.push(current->rightChild);
}
}
int main()
{
queue<int> Q;
vector<int> V;
int key, count;
cin >> count;
BinaryTree<int> tree;
for (int i = 0; i < count; i++)
{
cin >> key;
V.push_back(key);
}
sort(V.begin(), V.end());
for (auto e : V)
{
Q.push(e);
}
tree.Create(Q);
tree.LevelOrder();
return 0;
}
2.直接利用数组
上述代码纯粹是图个省事,在之前的代码上改了改,应该可以一次中序遍历边创建完全二叉树边赋值,不过那样需要计数确定左子树的范围,要改很多。
直接利用数组其实更方便省事,二叉树可以用数组来表示,而且用数组就只能严格按照完全二叉树的方式来存储,根节点和左子树结点的下标关系是二倍+1的关系,利用数组其实代码就简单很多了。
代码如下:
#include <iostream>
#include <algorithm>
#include <stack>
#include <queue>
#include <string>
using namespace std;
template <typename T>
void InOrder(vector<T> &V,int index,queue<T> &Q)
{
if (!Q.empty()&&index<V.size())
{
InOrder(V, (index + 1) * 2 - 1, Q);
V[index] = Q.front();
Q.pop();
InOrder(V, (index + 1) * 2 , Q);
}
}
int main()
{
queue<int> Q;
vector<int> V,R;
int key, count;
cin >> count;
for (int i = 0; i < count; i++)
{
cin >> key;
V.push_back(key);
}
sort(V.begin(), V.end());
for (auto e : V)
{
Q.push(e);
}
R.resize(V.size());
InOrder(R, 0, Q);
for (int i=0;i<R.size()-1;i++)
{
cout << R[i]<<" ";
}
cout << R.back();
return 0;
}
测试点
总结
记录下数据结构的学习过程吧,希望能促进自己学习。