判断是否同一棵二叉搜索树(二叉搜索树)

本文介绍了一种算法,用于判断多个插入序列是否能够生成相同的二叉搜索树。通过构建二叉搜索树并对比不同序列生成的树是否一致,实现对序列的验证。
04-树4 是否同一棵二叉搜索树(25 分)

给定一个插入序列就可以唯一确定一棵二叉搜索树。然而,一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树,都得到一样的结果。于是对于输入的各种插入序列,你需要判断它们是否能生成一样的二叉搜索树。

输入格式:

输入包含若干组测试数据。每组数据的第1行给出两个正整数N (10)和L,分别是每个序列插入元素的个数和需要检查的序列个数。第2行给出N个以空格分隔的正整数,作为初始插入序列。最后L行,每行给出N个插入的元素,属于L个需要检查的序列。

简单起见,我们保证每个插入序列都是1到N的一个排列。当读到N为0时,标志输入结束,这组数据不要处理。

输出格式:

对每一组需要检查的序列,如果其生成的二叉搜索树跟对应的初始序列生成的一样,输出“Yes”,否则输出“No”。

输入样例:

4 2
3 1 4 2
3 4 1 2
3 2 4 1
2 1
2 1
1 2
0

输出样例:

Yes
No
No

大意:先给出一棵二叉树搜索树作为初始树,再给出其他的二叉搜索树,判断新的二叉树与初始二叉树是否相同

附上AC代码:

#include <cstdio>   
#include <iostream> 
#include <algorithm> 
#include <cmath> 
#include <cstdlib> 
#include <cstring> 
#include <vector> 
#include <list> 
#include <map> 
#include <stack> 
#include <queue> 
using namespace std; 
#define ll long long
typedef struct Tree{
	int data;
	Tree *l,*r;
}*BiTree;
bool check[20];
void build(BiTree &T,int e)
{
	if(!T)
	{
		T = new Tree;
		T->data = e;
		T->l = T->r = NULL;
		return;
	}
	if(!T->l && e < T->data)
	{
		/*BiTree temp = new Tree;
		temp->l = temp->r = NULL;
		T->l = temp;
		temp->data = e;*/
		T->l = new Tree;
		T->l->l = T->l->r = NULL;
		T->l->data = e;
		return;
	}
	if(!T->r && e > T->data)
	{
		/*BiTree temp = new Tree;
		temp->l = temp->r = NULL;
		T->r = temp;
		temp->data = e;*/
		T->r = new Tree;
		T->r->l = T->r->r = NULL;
		T->r->data = e;
		return;
	}
	if(e > T->data)
		build(T->r,e);
	else
		build(T->l,e);
	return;
}
bool juge(BiTree T,int e)
{
	if(!check[T->data] && e != T->data)
		return false;
	check[T->data] = 1;
	if(e == T->data)
		return true;
	if(e < T->data)
		return juge(T->l,e);
	else
		return juge(T->r,e);
}
int main() 
{
	int n,l;
	while(cin >> n&&n)
	{
		cin >> l;
		BiTree T ;
		T = NULL;
		for(int i = 0;i < n;i++)
		{
			int x;
			cin >> x;
			build(T,x);
		}
		while(l--)
		{
			int f = 0;
			memset(check,0,sizeof(check));
			for(int i = 0;i < n;i++)
			{
				int x;
				cin >> x;
				if(!juge(T,x))
					f = 1;
			}
			if(f)
				cout << "No" <<endl;
			else
				cout << "Yes" <<endl;
		}
	} 
    //cout << "AC" <<endl; 
    return 0; 
} 

### 判断两组节点序列是否可以构成同一二叉搜索树判断两个节点序列是否能够生成相同的二叉搜索树(BST),可以通过构建两树并验证它们的结构一致性来完成。以下是具体的实现方法: #### 方法概述 1. 使用给定的两个节点序列分别构建两二叉搜索树。 2. 验证这两是否具有完全一致的结构和节点值。 为了实现上述功能,需要以下几个部分: - **构建二叉搜索树**:通过递归方式插入节点。 - **比较两树的一致性**:通过递归比较每一对对应节点及其子树。 --- #### 实现代码 以下是一个完整的 C 语言实现: ```c #include <stdio.h> #include <stdlib.h> // 定义二叉树节点结构体 typedef struct TreeNode { int value; struct TreeNode* left; struct TreeNode* right; } TreeNode; // 插入函数:用于构建二叉搜索树 TreeNode* insert(TreeNode* root, int value) { if (root == NULL) { // 如果当前为空,则创建新节点 TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode)); newNode->value = value; newNode->left = newNode->right = NULL; return newNode; } if (value < root->value) { // 小于当前节点值,进入左子树 root->left = insert(root->left, value); } else if (value > root->value) { // 大于当前节点值,进入右子树 root->right = insert(root->right, value); } // 值相等时不处理重复值的情况 return root; } // 构建二叉搜索树 TreeNode* buildTree(int array[], int size) { TreeNode* root = NULL; for (int i = 0; i < size; ++i) { root = insert(root, array[i]); } return root; } // 比较两是否相同 int areTreesEqual(TreeNode* tree1, TreeNode* tree2) { if (tree1 == NULL && tree2 == NULL) { // 两者均为空 return 1; } if (tree1 == NULL || tree2 == NULL) { // 其中之一为空 return 0; } if (tree1->value != tree2->value) { // 当前节点值不同 return 0; } // 递归比较左子树和右子树 return areTreesEqual(tree1->left, tree2->left) && areTreesEqual(tree1->right, tree2->right); } // 主函数测试 void test() { int sequence1[] = {8, 3, 10, 1, 6, 14, 4, 7, 13}; int sequence2[] = {8, 10, 3, 1, 6, 14, 4, 7, 13}; int n = sizeof(sequence1) / sizeof(sequence1[0]); TreeNode* bst1 = buildTree(sequence1, n); TreeNode* bst2 = buildTree(sequence2, n); if (areTreesEqual(bst1, bst2)) { printf("两组节点序列可以构成同一二叉搜索树。\n"); } else { printf("两组节点序列无法构成同一二叉搜索树。\n"); } // 清理内存(实际应用中应释放所有分配的节点) } ``` --- #### 关键点解析 1. **构建二叉搜索树** - `insert` 函数实现了标准的二叉搜索树插入逻辑[^1]。 - 对于每个输入值,根据其大小关系决定将其放置在左子树还是右子树中。 2. **比较两树** - `areTreesEqual` 函数递归地比较两树的每一层节点。 - 若任意一层存在差异,则返回不匹配的结果;否则继续深入下一层直到叶子节点[^4]。 3. **时间复杂度分析** - 构建单颗 BST 的时间为 \(O(n \log n)\),其中 \(n\) 是节点数量。 - 比较两树的时间复杂度同样为 \(O(n)\)[^3]。 --- #### 输出示例 假设输入如下两组序列: - 序列 1: `{8, 3, 10, 1, 6, 14, 4, 7, 13}` - 序列 2: `{8, 10, 3, 1, 6, 14, 4, 7, 13}` 运行结果可能为: ``` 两组节点序列可以构成同一二叉搜索树。 ``` 如果修改其中一个序列中的某个值(如将 `10` 改为 `-10`),则输出变为: ``` 两组节点序列无法构成同一二叉搜索树。 ``` --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值