二叉查找树（BST）

已于 2024-09-12 18:39:09 修改
阅读量1k 收藏 14
点赞数 14
CC 4.0 BY-SA版权
分类专栏： 算法与数据结构 文章标签： 算法 数据结构
于 2024-09-08 16:30:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/DaisyMaria/article/details/141824228

让我们先理解一下什么叫做二叉查找树；

 注意：二叉查找树的中序遍历序列总是呈现递增规律。

我们也可以通过 某棵树的的中序遍历序列是否呈现递增规律 来 判断 该树是否为 BST.

1.BST的建立

构建BST的过程就是将一系列互不相同的正整数依次插入到一棵初始为空的树中。

每次插入时，从根节点开始比较，根据大小关系决定插入到左子树还是右子树，直到找到合适的位置。

时空复杂度

  • 时间复杂度：

    • 插入操作的时间复杂度为O(h)，其中h是树的高度。在最坏情况下（例如，插入的序列是严格递增或递减的），树会退化成链表，高度为n，因此插入操作的总时间复杂度为O(n^2)。
    • 先序遍历的时间复杂度为O(n)，因为每个节点都会被访问一次。

  • 空间复杂度：

    • 主要的空间开销来自于递归栈和存储节点的数组。在最坏情况下，递归栈的深度为n，因此空间复杂度为O(n)。

核心代码：

 int newNode(int data)
{
    nodes[nodeCount].data = data;//按顺序存储结点数据
    nodes[nodeCount].l = nodes[nodeCount].r = -1;
    return nodeCount++;
}

int insert(int root, int data)
{
    //找到合适的空位置，开始创建二叉查找树上的新结点
    if (root == -1)
        return newNode(data);

    if (data < nodes[root].data)
    {
        //递归创建BST
        nodes[root].l = insert(nodes[root].l, data);
    }
    else
    {
        nodes[root].r = insert(nodes[root].r, data);
    }

    return root;
}

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 50;

struct Node
{
	int data;
	int r,l;
}nodes[MAXN];

int nodeCount = 0;

int newNode(int data)
{
	nodes[nodeCount].data = data;//按顺序存储结点数据
	nodes[nodeCount].l = nodes[nodeCount].r = -1;
	return nodeCount++;
}

int insert(int root, int data)
{
	//找到合适的空位置，开始创建二叉查找树上的新结点
	if (root == -1)
		return newNode(data);

	if (data < nodes[root].data)
	{
		//递归创建BST
		nodes[root].l = insert(nodes[root].l, data);
	}
	else
	{
		nodes[root].r = insert(nodes[root].r, data);
	}

	return root;
}

vector<int> pre;

void preOrder(int root)
{
	if (root == -1)return;

	pre.push_back(nodes[root].data);
	preOrder(nodes[root].l);
	preOrder(nodes[root].r);
}

int main()
{
	int n, data, root = -1;

	scanf("%d", &n);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &data);
		root = insert(root, data);//其实每次都会返回根结点
	}

	preOrder(root);

	for (int i = 0; i < pre.size(); i++)
	{
		printf("%d", pre[i]);
		if (i < (int)pre.size() - 1)
			printf(" ");
	}

	return 0;
}

2.二叉查找树的判定

 

注意：二叉查找树的中序遍历序列总是呈现递增规律。

因此在二叉查找树（Binary Search Tree, BST）中，中序遍历的结果是一个严格递增的序列。

因此，验证一个给定的中序遍历序列是否来自一个二叉查找树，只需检查该序列是否严格递增。

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <vector>
using namespace std;

vector<int> in;

bool isBST()
{
	for (int i = 1; i < in.size(); i++)
	{
		if (in[i] <= in[i - 1])
			return false;
	}

	return true;
}


int main()
{
	int n, x;
	scanf("%d", &n);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &x);
		in.push_back(x);
	}

	//输出结果
	printf(isBST() ? "Yes" : "No");
	return 0;
}

3.还原二叉查找树

 

不能由一个先序遍历序列确定唯一一棵BST，

但是由6.先序中序还原二叉树知，可以通过一个先序遍历序列和一个中序遍历序列确定唯一一棵二叉树，（或是中序+后序，但前序和后序不行。因为前序和后序在本质上都是将父节点与子结点进行分离，但并没有指明左子树和右子树的能力，因此得到这两个序列只能明确父子关系，而不能确定一个二叉树）

题目已给出一个先序遍历序列，而对于二叉查找树，中序遍历序列是一个有序序列，我们可以通过将先序遍历序列排序得到中序遍历序列。

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 50;

struct Node
{
	int data;
	int r, l;
}nodes[MAXN];

int nodeCount = 0;

int newNode(int data)
{
	nodes[nodeCount].data = data;//按顺序存储结点数据
	nodes[nodeCount].l = nodes[nodeCount].r = -1;
	return nodeCount++;
}

vector<int> pre,in,post;

int buildTree(int preL, int preR, int inL, int inR)
{
	if(preL>preR)
	{
		return -1;
	}

	int root = newNode(pre[preL]);//创建根结点
	int inIndexOfRoot;
	for (int i = inL; i <= inR; i++)
	{
		if (in[i] == nodes[root].data)
		{
			inIndexOfRoot = i;
			break;
		}
	}

	int leftCount = inIndexOfRoot - inL;//左子树结点数
	nodes[root].l = buildTree(preL + 1, preL + leftCount, inL, inIndexOfRoot - 1);//构建左子树
	nodes[root].r = buildTree(preL + leftCount + 1, preR, inIndexOfRoot + 1, inR);//构建右子树
	return root;
}


void postOrder(int root)
{
	if (root == -1)return;

	postOrder(nodes[root].l);
	postOrder(nodes[root].r);
	post.push_back(nodes[root].data);
}

int main()
{
	int n,x;

	scanf("%d", &n);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &x);
		pre.push_back(x);
	}

	//获得中序遍历序列
	in = pre;
	sort(in.begin(), in.end());

	int root = buildTree(0, n - 1, 0, n - 1);

	postOrder(root);

	for (int i = 0; i < post.size(); i++)
	{
		printf("%d", post[i]);
		if (i < (int)post.size() - 1)
			printf(" ");
	}

	return 0;
}

4.相同的二叉查找树

由题3，我们知道，得知一个BST的先序遍历序列，自然可以知晓它的中序遍历序列。

因此，要判断两棵二叉查找树是否相同，可以通过比较它们的前序遍历序列来实现。

前序遍历序列能够唯一地确定一棵二叉查找树的结构。

（我个人认为后序遍历序列也是可以的，实际上用后序也的确可以通过）

代码如下（先序）：

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <vector>
using namespace std;

const int MAXN = 50*2;

struct Node
{
	int data;
	int r, l;
}nodes[MAXN];

int nodeCount = 0;

int newNode(int data)
{
	nodes[nodeCount].data = data;//按顺序存储结点数据
	nodes[nodeCount].l = nodes[nodeCount].r = -1;
	return nodeCount++;
}

int insert(int root, int data)
{
	if (root == -1) return newNode(data);
	
	if (data < nodes[root].data) nodes[root].l = insert(nodes[root].l, data);
	else nodes[root].r = insert(nodes[root].r, data);

	return root;
}


void preOrder(int root, vector<int>& pre) {
	if (root == -1) {
		return;
	}
	pre.push_back(nodes[root].data); // 访问根节点
	preOrder(nodes[root].l, pre); // 遍历左子树
	preOrder(nodes[root].r, pre); // 遍历右子树
}


int main()
{
	int n, data;
	scanf("%d", &n);
	
	int root1 = -1, root2 = -1;
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &data);
		root1 = insert(root1, data);
	}
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &data);
		root2 = insert(root2, data);
	}

	vector<int> pre1, pre2;
	preOrder(root1, pre1);
	preOrder(root2, pre2);

	printf(pre1 == pre2 ? "Yes" : "No");

	return 0;
}

5.填充二叉查找树

 废话不多说，上代码

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 50*2;

vector<int> pre, in;

struct Node
{
	int data;
	int r, l;
}nodes[MAXN];

int inIdx=0;

void inOrder(int root)
{
	if (root == -1)
		return;
	inOrder(nodes[root].l);
	nodes[root].data = in[inIdx++];
	inOrder(nodes[root].r);
}

void preOrder(int root)
{
	if (root == -1)  return;

	pre.push_back(nodes[root].data);
	preOrder(nodes[root].l);
	preOrder(nodes[root].r);
}


int main()
{
	int n, x;
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &x);
		in.push_back(x);
	}
	for (int i = 0; i < n; i++)
	{
		scanf("%d%d", &nodes[i].l, &nodes[i].r);
	}

	sort(in.begin(), in.end());
	inOrder(0);
	preOrder(0);

	for (int i = 0; i < (int)pre.size(); i++)
	{
		printf("%d", pre[i]);
		if (i < (int)pre.size() - 1)
			printf(" ");
	}

	return 0;
}

数据结构：二叉查找树 BST 平均查找长度 ASL 的计算
寒泉
11-09 8万+
平均查找长度 ASL（Average Search Length），即平均查找长度，在查找运算中，由于所费时间在关键字的比较上，所以把平均需要和待查找值比较的关键字次数称为平均查找长度。 它的定义是这样的： 其中n为查找表中元素个数，Pi为查找第i个元素的概率，通常假设每个元素查找概率相同，Pi=1/n，Ci是找到第i个元素的比较次数。 顺序查找平均查找长度的计算 在顺序查找(Sequence Search)表中，查找方式为从头扫到尾，找到待查找元素即查找成功，若到尾部没有找到，说明查找失败。 所以说，Ci
b+树时间复杂度_一篇文章搞懂二叉树、红黑树、B树
weixin_39734020的博客
11-24 3742
二叉查找树：#二叉查找树就是左结点小于根节点，右结点大于根节点的一种排序树，也叫二叉搜索树。也叫BST，英文Binary Sort Tree。就长下面这吊样查找步骤#在二叉搜索树b中查找x的过程为：若b是空树，则搜索失败，否则：若x等于b的根节点的数据域之值，则查找成功；否则：若x小于b的根节点的数据域之值，则搜索左子树；否则：查找右子树。二叉搜索树的构造#往BST中插入元素#BST转成有序数组#...
二叉排序树(BST)的构建及基本操作Java实现
热门推荐
猪奥奥的Blog
09-23 1万+
二叉排序树一、基本概念二、思路分析三、代码实现 一、基本概念 二叉排序树，又称二叉查找树，亦称二叉搜索树。对于二叉排序树， 二、思路分析 三、代码实现
【数据结构实验】树（一）构建二叉查找树(BST)
最新发布
天地玄黄 魑魅魍魉 风花雪月 商角徵羽
12-05 1137
实验通过C语言构建一个二叉查找树，并计算了其平均查找长度。
【二叉树】数据结构——BST二叉树基本概念及算法设计（插入、删除、遍历操作）
皮皮不调皮的博客
03-29 4960
二叉树一、二叉树基本概念二、二叉树的算法设计1、构建二叉树节点2、插入节点3、删除节点4、遍历二叉树5、层次遍历 一、二叉树基本概念 二叉树的其中一个重要应用，是提供一种快速查找数据的方法，即：将数据节点按照某种规律形成一棵二叉树，然后利用二叉树特殊的逻辑结构减少搜索数据的次数，提高查找的效率。 这种按照某种规律构建，用来提高搜索性能的二叉树，被称为搜索二叉树（Binary Search Tree），即BST。 具体而言，二叉树提高搜索效率的秘诀在于：按照“小-中-大”（当然“大-中-小”也是一样的）的规律
BST学习总结
u011883637的专栏
12-08 1463
BST全名为Binary Search Tree，中文叫二叉搜索树。支持在线插入、搜索第K小（或大）、Rank、搜索前驱后继的操作，单次操作时间复杂度，空间复杂度。BST的性质为：左子树
数据结构及算法 | Java数据结构——BST二叉搜索树（上）
是袁同学呀
06-29 387
一、BST相关概念 BST（二叉搜索树）可以实现增加、删除、搜索的时间复杂度都为log2n(以2为底，并非2n)。关于树的基础概念根据图中数据解释以便理解： 58是根节点root；23是58的左孩子；82是58的右孩子； 23是12和35的父节点；12是23的左孩子；35是23的右孩子； 而23作为父节点，它的左孩子以及孩子和孩子，即23、12、35、18、47这些叫做58的左子树；他的右孩子及孩...
TreeSWT:利用SWT来图形化显示二叉树 目前支持二叉查找树BST
05-11
`TreeSWT`项目正是一款利用`SWT`（Standard Widget Toolkit）库来实现二叉树图形化的工具，特别针对二叉查找树（Binary Search Tree, BST）进行了优化支持。本文将深入探讨`TreeSWT`的实现原理、功能以及如何在...
详解二叉查找树BST及其遍历算法
二叉查找树（Binary Search Tree，简称BST）是一种重要的数据结构，它支持多种动态集合操作，如查找、插入、删除等。在计算机科学与信息处理领域中，BST是一种广泛应用于各种系统和应用的高效数据结构，特别是在需要...
二叉查找树BST，可以看看
12-13
二叉查找树（Binary Search Tree，简称BST），是一种特殊的二叉树数据结构，它具有以下特性：对于树中的任意一个节点，其左子树中所有节点的值都小于该节点的值，而右子树中所有节点的值都大于该节点的值。...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
查找算法系列之复杂算法：二叉排序树BST
susandebug
06-25 4583
前面总结了顺序查找，二分查找，分块查找算法，此篇博文将详解介绍二叉排序算法（Binary Sort Tree）。 在介绍二叉排序算法之前，首先介绍什么事二叉排序树（BST）。 首先从二叉树讲起： 1、二叉树的概念 二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作“左子树”（leftsubtree）和“右子树”（rightsubtree）。二叉树常被用作二叉查找树和二叉
BST的查找、插入、删除
JTY541464341的博客
03-30 891
BST的查找、插入、删除 BST (binary search tree) 二叉搜索树 结合了vector和list的优点 主要接口有三种：查找，插入，删除 查找： 时间复杂度O(h)（即不超过树的高度） 由于BST在局部具有顺序性、在整体具有单调性的特点，因此BST的直接投影与其中序遍历相符合。关键码从左到右依次单调递增。 在查找目标关键码时，动作类似于vector中的二分查找。因为BST的...
BST：有序数组构建成二叉搜索树
大智若鱼
08-14 5401
有序数组构建成二叉搜索树,使用x=change(x)模式 降序储存和顺序储存都会得到退化树。最有效保持树平衡的是，取数组中值（对于无重复元素的有序数组，中值就是数组中间元素）作为树根的值，将数组分为左右两个子数组，左子数组的数值均小于根节点，右子数组的值均大于根节点。将左子数组的中间元素作为根节点的左子树，将右子树的中间元素作为根节点的右子树，由此，形成递归关系，就能得到平衡的二叉搜索树。
二叉排序树（BST）的构建与删除
卖核弹的小男孩 的博客
04-29 322
二叉排序树（BST）的构建，插入，查找与删除 二叉排序树的删除结点分为三种情况 （1）叶子结点 这种情况最简单，由于删除叶子结点不会破坏整棵树的结构，只需要修改其双亲结点的指针即可 （2）要删除的结点只求左子树或者右子树 相对而言也比较简单，只需要删除结点后，将它的左子树或右子树整个移动到删除节点的位置即可。 #include<iostream> using namespace std...
二叉树的构建--BST
Bing's Blog
09-09 1472
很久没有写树的构建程式了，题目中用到，发现手非常生，写出来总是有bug，单步运行才排除错误。 本篇博文就是一次回顾。这次树的存储方式选用的是链接存储方式。 结点结构定义依旧是：typedef struct Node { int data; Node *left; Node *right; }TNode;很多书上的代码都省略了typedef，但是我省略以后测试不通过，具体细
二叉搜索树(BST)的创建、插入、查找和删除
MSP_甄心cherish的专栏
06-21 1万+
树的结构体定义 struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; 插入 因为二叉搜索树不允许存在相等的值，所以插入有可能失败 非递归版 bool BSTInsert(TreeNode* &root
二叉查找树（BST）｜搜索及插入操作
嗅探网的博客
08-30 808
假设我们要搜索数字，我们从根开始，然后我们将要搜索的值与根的值进行比较，如果相等，我们完成搜索，如果它更小，我们知道我们需要转到左子树，因为在二叉查找树中，左子树中的所有元素都较小，而右子树中的所有元素都较大。为了搜索一个值，如果我们有一个排序数组，我们可以通过二分查找法来进行搜索。在二分查找中，我们从搜索空间中的“n”个元素开始，如果中间元素不是我们正在寻找的元素，我们将搜索空间减少到“n/2”，以此类推我们不断缩小搜索空间，直到我们找到想要寻找的值，或者我们将搜索空间缩小到一个元素并停止搜索。.....
【数据结构】二叉查找树（BST）
m0_46628950的博客
09-08 7949
二叉查找树(Binary Search Tree，BST)，又叫做二叉排序树、二叉搜索树，是一种对查找和排序都有用的特殊二叉树。二叉查找树的特性：左子树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值