您的位置：首页 > 其它

4-06. 搜索树判断

2014-12-06 22:54 239 查看
对于二叉搜索树，我们规定任一结点的左子树仅包含严格小于该结点的键值，而其右子树包含大于或等于该结点的键值。如果我们交换每个节点的左子树和右子树，得到的树叫做镜像二叉搜索树。

现在我们给出一个整数键值序列，请编写程序判断该序列是否为某棵二叉搜索树或某镜像二叉搜索树的前序遍历序列，如果是，则输出对应二叉树的后序遍历序列。

输入格式说明：

输入的第一行包含一个正整数N（<=1000），第二行包含N个整数，为给出的整数键值序列，数字间以空格分隔。

输出格式说明：

输出的第一行首先给出判断结果，如果输入的序列是某棵二叉搜索树或某镜像二叉搜索树的前序遍历序列，则输出“YES”，否侧输出“NO”。如果判断结果是“YES”，下一行输出对应二叉树的后序遍历序列。数字间以空格分隔，但行尾不能有多余的空格。

样例输入与输出：
序号输入输出
1
7
8 6 5 7 10 8 11

YES
5 7 6 8 11 10 8

2
7
8 10 11 8 6 7 5

YES
11 8 10 7 5 6 8

3
7
8 6 8 5 10 9 11

NO

4
16
100 70 60 62 68 65 69 200 150 140 160 155 300 400 500 450

YES
65 69 68 62 60 70 140 155 160 150 450 500 400 300 200 100

5
17
85 92 100 120 110 105 88 90 50 20 30 40 35 36 32 28 15

YES
105 110 120 100 90 88 92 36 32 35 40 28 30 15 20 50 85

6
7
8 6 7 5 10 11 9

NO

7
1
-1

YES
-1


#include<iostream>
#include<vector>
#include<iterator>
using namespace std;

struct node{
int key;
struct node *lchild;
struct node *rchild;
node();
node(int k){
key = k;
lchild = NULL;
rchild = NULL;
}
};

struct node* T1 = new struct node(0);
struct node* T2 = new struct node(0);	//the tree's root, 2-tree is mirrot tree
int N;	//number of elements

void insertnode(struct node *newer, struct node *n)
{
if(n->lchild==NULL && n->key > newer->key)
n->lchild = newer;
else if(n->rchild==NULL && n->key <= newer->key)
n->rchild = newer;
else if(n->lchild!=NULL && n->key > newer->key)
insertnode(newer, n->lchild);
else if(n->rchild!=NULL && n->key <= newer->key)
insertnode(newer, n->rchild);
}

void tree_create(vector<int> elements, struct node *T)
{
vector<int>::iterator iter = elements.begin();
struct node *temp;

T->key = *iter;
for(iter++;iter!=elements.end(); iter++)
{
temp = new struct node(*iter);
insertnode(temp, T);
}

}

void mirrorinsertnode(struct node *newer, struct node *n)
{
if(n->lchild==NULL && n->key <= newer->key)
n->lchild = newer;
else if(n->rchild==NULL && n->key > newer->key)
n->rchild = newer;
else if(n->lchild!=NULL && n->key <= newer->key)
mirrorinsertnode(newer, n->lchild);
else if(n->rchild!=NULL && n->key > newer->key)
mirrorinsertnode(newer, n->rchild);
}

void mirrortree_create(vector<int> elements, struct node *T)
{
vector<int>::iterator iter = elements.begin();
struct node *temp;

T->key = *iter;
for(iter++;iter!=elements.end(); iter++)
{
temp = new struct node(*iter);
mirrorinsertnode(temp, T);
}
}

void pre_order(struct node *n, vector<int> &elements)
{
if(n == NULL)
return;
else
{
elements.push_back(n->key);
pre_order(n->lchild, elements);
pre_order(n->rchild, elements);
}
}

bool isSearchTree(struct node *T, vector<int>elements)
{
vector<int> out;

out.push_back(T->key);
pre_order(T->lchild, out);
pre_order(T->rchild, out);

if(out == elements)
return true;
else
return false;
}

void follow_order(struct node *n, vector<int> &out)
{
if(n == NULL)
return;
else
{
follow_order(n->lchild, out);
follow_order(n->rchild, out);
out.push_back(n->key);
}
}

void print_result(struct node *T, vector<int> &out)
{
follow_order(T->lchild, out);
follow_order(T->rchild, out);
out.push_back(T->key);
}

int main()
{
cin >> N;
vector<int> out;
vector<int> elements;
vector<int>::iterator iter;
int temp;
int flag = 0;
int i;
bool bSearchTree, bMirrorSearchTree;
for(i=0; i<N; i++)
{
cin>>temp;
elements.push_back(temp);
}

tree_create(elements, T1);
mirrortree_create(elements, T2);

bSearchTree = isSearchTree(T1, elements);
bMirrorSearchTree = isSearchTree(T2, elements);
if(!bSearchTree && !bMirrorSearchTree)
cout<< "NO"<< endl;
else
{
cout<< "YES"<< endl;
if(bSearchTree)
{
print_result(T1, out);
}
else
{
print_result(T2, out);
}
for(iter=out.begin(); iter!=out.end(); iter++)
{
if(flag == 0)
{
flag = 1;
cout<<*iter;
}
else
{
cout<<' '<<*iter;
}
}
cout<<endl;
}

return 0;
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航