真c++ 从二叉树到红黑树（3）之二叉搜索树BST

最新推荐文章于 2021-07-11 10:46:44 发布
最新推荐文章于 2021-07-11 10:46:44 发布
阅读量281 收藏 2
点赞数 1
分类专栏： C++数据结构与算法 文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bioinformatique/article/details/106144982
版权

  此文章为从二叉树到红黑树系列文章的第三节，主要介绍介绍二叉搜索树BST，为AVL和RedBlack打下基础


文章目录

一、前面文章链接~（点击右边波浪线可以返回目录）

  在阅读本文前，强烈建议你看下前面的文章的目录、前言以及基本介绍，否则你无法理解后面的内容。链接如下：

  1. 基本二叉树节点，通用函数 二叉树节点
  2. 基本二叉树类的定义和实现 二叉树基类

二、二叉搜索树BST的定义~

  确认一颗树的中序遍历序列十分容易。即将树中每一个元素都投影到底部就可以了。

  当一颗树的中序遍历序列是单调非减的时候，那么这颗树就必为一颗BST，即二叉搜索树。

  更准确一点的定义为：根节点的值大于其左子树中任意一个节点的值，小于其右节点中任意一节点的值。其左子树和右子树也都满足这个条件。

  二叉搜索树，又称二叉排序树，二叉查找树。

如下图所示
在这里插入图片描述

三、二叉搜索树类~

  既然二叉搜索树属于二叉树的特例，故自然可以基于BinTree模板类（见此系列文章第二部分）

  由于BST继承于普通二叉树。而普通二叉树的大部分函数和变量都是属于public或者protected的。自然BST可以沿用这些函数和变量。

  并由于BST本身特殊的性质（单调非减），因此需要对某些函数进行重写（override）。以及扩增一些新的功能。

  在此，为了方便性起见，我们默认BST中没有重复的数（读者可以自行更改search接口的判断条件来进行扩充）。

（一）定义变量和接口~

1.需要的变量~

  _hot节点，此节点的设定至关重要，有了这个节点，就能简化很多步骤，方便BST包括后序的AVL，RedBlack的插入和删除。读者看到后面的插入和删除算法的实现的时候，自然能够体会到这个节点的作用。

BinNodePtr _hot;//"命中节点"的"父亲"

2.需要的接口~

  由于BST是继承于BinTree的，因此，很多接口都可以沿用BinTree的接口，比如遍历，判空，获取当前高度等等。但依然有些接口是需要进行扩充和重写的。

比如：

查找树中有没有这个节点search
在树中插入一个节点insert
在树中删除一个节点remove

3.重要辅助函数~

  对于BST本身，有了上面的查找，插入和删除，已经可以满足BST本身的要求了，但是对于后序的AVL和RedBlack而言，还远远不够，因此在此处会引入两个重要的辅助函数，并且我会在介绍AVL的时候，详细说明这两个辅助函数的作用。在介绍RedBlack的时候，也会引入一个指向AVL的链接。

  关于下面两个函数的实现，我不会在本节进行解析，我会在AVL中再进行解析。

3+4重构 connect34
对该节点及其父亲、祖父做统一旋转调整rotateAt

4.BST.h~

  由于BST属于二叉树的一种，因此，可以将BST继承自我们在第二部分定义的BinTree。

template<typename T=int>
class BST :public BinTree<T> {
protected:
	using BinNodePtr = BinNode<T>*;

protected:
	BinNodePtr _hot;//"命中节点"的"父亲"

public:
	BST():_hot(nullptr){}//调用构造函数时，先调用子类的，再调用父类，析构则相反
	virtual~ BST() = default;//由于删除全部交给b树模板类，所以这里不需要去额外删除

protected:
	BinNode<T>* connect34(//3+4重构，可以用于AVL,RedBlack
		BinNode<T>*, BinNode<T>*, BinNode<T>*,
		BinNode<T>*, BinNode<T>*, BinNode<T>*, BinNode<T>*);

	BinNode<T>* rotateAt(BinNode<T>* v);//对v及其父亲、祖父做统一旋转调整

private:
	BinNode<T>*& search_R(const T& data);//查找递归版

public:
	BinNode<T>*& search(const T& data);//查找//返回引用，便于插入删除//接受者一般要加个引用接收

	virtual BinNode<T>* insert(const T& data)override;//插入节点

	virtual bool remove(const T& data);//删除节点

};//class BST

（二）查找search~

  从树根出发，逐步地缩小查找范围，直到发现目标（成功）或缩小至空树（失败）。由于BST的中序遍历是有序的，所以可以用二分查找法。

比如下方查找22和23

在这里插入图片描述
  找22时，先与根节点比较大小，其比根节点16大，则进入右子树查找。下一次与25相比，22比25小，所以进入左子树查找。然后与19对比，自然进入右分支，最后正好命中22这个节点。即查找成功。

  找23时，也会经过这样一条道路，由于22的右子树为空，所以查找失败。

1._hot节点的作用~

  若查找成功，则search()的返回值都将如下图(a)所示，指向一个数值为e且真实存在的节点；
  若查找失败，则返回值的数值虽然为NULL，但是它作为引用将如下图(b)所示，指向最后一次试图转向的空节点。

在这里插入图片描述
  由上图可以得知，无论查找成功或者失败，查找的返回值都是等效地指向“命中节点”，而命中节点的父亲节点就是_hot节点。有了_hot节点，对于插入和删除，都会变得相对容易一点。

2.查找递归版~

  众所周知，二分查找可以写成递归或者迭代形式。并且幸运的是，对于二叉树而言，其二分查找的算法，与一般数组的查找算法相比，本质上没有任何区别，甚至可以说比一般的二分查找算法更加简单一点。

  由于递归算法需要不断地调用自身，并且为了保持与非递归算法的接口传入参数的一致性，所以不妨将递归的部分与不需要递归的部分分离开来。

  下面是主要查找函数的接口。当需要查找一个数据时，就从根节点开始，进行二分递归查找。并同时更新_hot节点的值，方便后续的插入和删除。

  并且返回值注意为引用类型。这点对于删除算法而言至关重要。

template<typename T>
BinNode<T>*& BST<T>::search_R(const T& data) {
	using mybst::search_In;
	return search_In(this->_root, data, _hot = nullptr);
}

下方为二分查找的递归算法

//=================查找================//
namespace mybst {
	template<typename T,typename BinNodePtr>
	static BinNode<T>*& search_In(BinNodePtr& current, const T& data, BinNodePtr& hot) {//必须加引用，不然地址改变的话，原地址不能改变
		if (!current || data == current->_data)
			return current;//递归基，当当前节点为空或者找到了对应的节点，就退出
		hot = current;//hot 记录父亲节点的位置
		return search_In((data < current->_data ? current->_lchild : current->_rchild), data, hot);//二分递归查找
	}
}//namespace mybst

3.查找迭代版~

  比起分开写的递归算法，笔者认为迭代版的查找算法的可读性相对更高一点，并且效率也更高一点。同样，也要注意返回的是引用。
  后面在插入和查找过程中，都默认用的是迭代版算法。

template<typename T>
BinNode<T>*& BST<T>::search(const T& data) {
	if (!this->_root || data == this->_root->_data) {//如果根节点不为空，或者正好根节点就是要找的节点
		_hot = nullptr;
		return this->_root;
	}
	_hot = this->_root;//更新_hot

	while (true){
		//current的地址与_hot的孩子绑定，不能与_hot绑定。
		BinNodePtr& current = ((data < _hot->_data) ? _hot->_lchild : _hot->_rchild);
		if (!current || data == current->_data)
			return current;
		_hot = current;//更新_hot位置
	}
}

4.search复杂度分析~

  在二叉搜索树的每一层，查找算法至多访问一个节点，且只需常数时间，故总体所需时间应线性正比于查找路径的长度，或最终返回节点的深度，在最坏情况下不超过全树的高度。

（三）插入insert~

  对于BST而言，无论是插入还是删除而言，先前都必将要经过查找操作。对于在此系列定义的BST而言，里面存放的都是不可重复的数据。因此，对于插入而言，如果这个元素存在BST中，则不插入，如果在BST中不存在这个元素，就在适合的位置插入这个元素。

  在此，_hot节点的作用就体现出来了，如果不存在这个元素，_hot节点也必将是假设这个不存在的元素存在时的父亲节点。

1.插入代码~

//=================插入================//
template<typename T>
BinNode<T>* BST<T>::insert(const T& data) {
	BinNodePtr& x = search(data);//查找有无这个节点//必须用引用，这样其才必然是_hot的孩子
	if (x)//若有，则返回这个节点，插入失败
		return x;
	x = new BinNode<T>(data, _hot);//若无，则新建一个节点，并将_hot节点作为其父节点连接到树上
	this->_size++;//更新规模
	this->updateHeightAbove(x);//更新高度。
	return x;
}

  请读者好好体会这段简短但不简单的代码所表达的意思。特别是引用的用处。
  并且插入后也要更新相应的节点高度，以及其祖先节点的高度。关于高度更新的算法实现，请见本系列文章第二部分。

2.插入示例（动图演示!）~

在下图中插入21

在这里插入图片描述

3.insert复杂度分析~

  节点插入操作所需的时间，主要消耗于对算法search()及updateHeightAbove()的调用。后者与前者一样，在每一层次至多涉及一个节点，仅消耗O(1)时间，故其时间复杂度也同样取决于新节点的深度，在最坏情况下不超过全树的高度。

（四）删除remove~

  理解BST的删除算法，可以说是BST最重要的一点，弄懂了BST的删除，那么你就懂了BST，接下来介绍一个最重要的删除静态函数，这个函数不仅对于BST有用，对于AVL，RedBlack都有用。

1.最重要的删除函数（动图演示!）~

  删除一颗BST的节点，并且保持BST的性质，需要分以下3种大情况来考虑。

（1）该节点没有子树~
直接删除该节点既可，并且修改对应指针地址
如下图删除节点21

在这里插入图片描述

（2）该节点只有一颗子树~
a.只有左子树~
则其左子树接替它的位置，并且修改对应指针地址
如下图删除节点29

在这里插入图片描述

b.只有右子树~
则其右子树接替它的位置，并且修改对应指针地址
如下图删除节点29

在这里插入图片描述

（3）该节点有两颗子树~

  在此，需要借用在本系列文章第一部分提到的关于求当前节点的直接后继算法。建议看完这个算法的实现，再来理解这种情况，否则你会感到迷惑。

  首先要在心里明确一个事实：即直接后继，必然没有左孩子。

a.右孩子就是该节点的直接后继~

  在这种情况下，可以得知，该右孩子必然没有左孩子（可能有右孩子），不然其右孩子不可能作为其直接后继。此时，就将该节点与其后继（也就是右孩子）的值进行交换（看下面代码你就能明白交换比直接删这个节点更好）。再重新连接指针即可。

下面图示为了简单起见，没有体现交换的过程
如下图删除节点20

在这里插入图片描述

b.该节点的直接后继在右孩子的左子树中~

  在这种情况下，可以得知，该节点的直接后继必然是左孩子。此时，就将该节点与其后继（也就是右孩子）的值进行交换。再重新连接指针即可。

下面图示为了简单起见，没有体现交换的过程
如下图删除节点65

在这里插入图片描述

（4）删除静态函数代码~

此代码为删除算法的难点，重点，理解好此代码，你才能理解进一步的AVL，RedBlack！

  其中HasLChid等全局函数，位于第一部分定义的BInNode_Macro.h中，succ()算法位于第一部分求直接后继的算法中，release删除函数位于第二部分定义的release.h中。

//=================删除================//
template<typename T>//适用于AVL Splay,RedBlack等，必须这么设计，才能做到完美删除，且保持BST的性质
static BinNode<T>* removeAt(BinNode<T>*& x, BinNode<T>*& hot) {//这里x必须用引用，才不会使指针乱指
	using BinNodePtr = BinNode<T>*;								

	//记录x的地址里面保存的值，若删除temp里面的值，即删除x里面的值，但x的本身地址不会影响temp，反之亦然。
	BinNodePtr temp = x;

	//替代被删除节点的接替者，一般为被删除节点的左孩子或者右孩子，而不是x的左孩子或者右孩子
	BinNodePtr replacer = nullptr;

	if (!HasLChild(x)) {//如果x没有左孩子，或者x左右孩子均无，则将x的右孩子作为x，并将接替者设为x的右孩子
		x = x->_rchild;
		replacer = x;
	}
	else if (!HasRChild(x)) {//如果x没有右孩子，则将x的左孩子作为x，并将接替者设为x的左孩子
		x = x->_lchild;
		replacer = x;
	}
	else {
		temp = temp->succ();//取得中序遍历的后继//这个后继必将没有左孩子
		std::swap(x->_data, temp->_data);//交换对应的值
		if (temp->_parent == x) {//如果后继的父亲是原来的x，后继必然为x的右孩子
			replacer = temp->_rchild; //就将后继的右孩子作为父亲的右孩子
			temp->_parent->_rchild = replacer;
		}
		else {//如果后继的父亲不是原来的x，后继必然为某一节点的左孩子
			replacer = temp->_rchild;
			temp->_parent->_lchild=replacer;//就将后继的右孩子作为这个节点左孩子
		}
	}
	//hot即被删除节点的父亲。而temp正是要删除的节点。
	hot = temp->_parent;
						
	if (replacer)//若replacer存在，则必须将其父指针指向hot。不然如同x->_rchild的父亲指向的还是原来的
		replacer->_parent = hot;
	
	//释放原来x所指的堆区的数据，或者x的后继的堆区的数据
	release(temp->_data);
	release(temp);

	return replacer;
}

2.BST的删除代码~

  理解了上面的代码，就能很容易理解BST的删除。

  同样先前都必将要经过查找操作。对于在此系列定义的BST而言，里面存放的都是不可重复的数据。因此，对于删除而言，如果这个元素存在BST中，则进行删除，如果在BST中不存在这个元素，就返回false。

  在此，_hot节点的作用就体现出来了，如果存在这个元素，在经过removeAt算法后，_hot节点也必将是被删除节点的父亲节点，此时，更新高度，只需要更新_hot节点的高度既可。

template<typename T>
bool BST<T>::remove(const T& data) {
	BinNodePtr& x = search(data);//接收返回的值，这里用引用
	if (x == nullptr)//若没找到
		return false;//返回false
	removeAt(x, _hot);//删除找到的节点
	this->_size--;//更新规模
	this->updateHeightAbove(_hot);//更新高度
	return true;
}

3.remove复杂度分析~

  删除操作所需的时间，主要消耗于对search()、succ()和updateHeightAbove()的调用。在树中的任一高度，它们至多消耗O(1)时间。故总体的渐进时间复杂度，亦不超过全树的高度。

（五）完整BST.h~

  注意，connect34算法和rotateAt算法，我会在AVL中再进行介绍

#pragma once
#include "BinTree.h"

namespace mytree {
	using namespace mytree_marcro;

	template<typename T=int>
	class BST :public BinTree<T> {
	protected:
		using BinNodePtr = BinNode<T>*;

	protected:
		BinNodePtr _hot;//"命中节点"的"父亲"

	public:
		BST():_hot(nullptr){}//调用构造函数时，先调用子类的，再调用父类，析构则相反
		virtual~ BST() = default;//由于删除全部交给b树模板类，所以这里不需要去额外删除

	protected:
		BinNode<T>* connect34(//3+4重构，可以用于AVL,RedBlack
			BinNode<T>*, BinNode<T>*, BinNode<T>*,
			BinNode<T>*, BinNode<T>*, BinNode<T>*, BinNode<T>*);

		BinNode<T>* rotateAt(BinNode<T>* v);//对v及其父亲、祖父做统一旋转调整

	private:
		BinNode<T>*& search_R(const T& data);//查找递归版

	public:
		BinNode<T>*& search(const T& data);//查找//返回引用，便于插入删除//接受者一般要加个引用接收

		virtual BinNode<T>* insert(const T& data)override;//插入节点

		virtual bool remove(const T& data);//删除节点

	};//class BST

	template<typename T>
	BinNode<T>* BST<T>::connect34(
		BinNode<T>* a, BinNode<T>* b, BinNode<T>* c,
		BinNode<T>* T1, BinNode<T>* T2, BinNode<T>* T3, BinNode<T>* T4)
	{
		a->_lchild = T1; if (T1)T1->_parent = a;
		a->_rchild = T2; if (T2)T2->_parent = a; this->updateHeight(a);
		c->_lchild = T3; if (T3)T3->_parent = c;
		c->_rchild = T4; if (T4)T4->_parent = c; this->updateHeight(c);
		b->_lchild = a; a->_parent = b;
		b->_rchild = c; c->_parent = b; this->updateHeight(b);
		return b;
	}

	template<typename T>
	BinNode<T>* BST<T>::rotateAt(BinNode<T>* v) //返回调整后局部子树根节点的位置
	{
		if (v == nullptr) {
			printf("Error!"); exit(0);
		}
		BinNode<T>* p = v->_parent; BinNode<T>* g = p->_parent;//设定v的父亲与祖父//视v、p和g相对位置分四种情况
		if (IsLChild(p)) {//L
			if (IsLChild(v)) {//LL
				p->_parent = g->_parent;//向上连接
				return connect34(v, p, g, v->_lchild, v->_rchild, p->_rchild, g->_rchild);
			}
			else {//LR
				v->_parent = g->_parent;//向上连接
				return connect34(p, v, g, p->_lchild, v->_lchild, v->_rchild, g->_rchild);
			}
		}
		else {//R
			if (IsRChild(v)) {//RR
				p->_parent = g->_parent;//向上连接
				return connect34(g, p, v, g->_lchild, p->_lchild, v->_lchild, v->_rchild);
			}
			else {//RL
				v->_parent = g->_parent;//向上连接
				return connect34(g, v, p, g->_lchild, v->_lchild, v->_rchild, p->_rchild);
			}
		}
	}

	//=================查找================//
	namespace mybst {
		template<typename T,typename BinNodePtr>
		static BinNode<T>*& search_In(BinNodePtr& current, const T& data, BinNodePtr& hot) {//必须加引用，不然地址改变的话，原地址不能改变
			if (!current || data == current->_data)
				return current;//递归基，当当前节点为空或者找到了对应的节点，就退出
			hot = current;//hot 记录父亲节点的位置
			return search_In((data < current->_data ? current->_lchild : current->_rchild), data, hot);//二分递归查找
		}
	}//namespace mybst

	template<typename T>
	BinNode<T>*& BST<T>::search_R(const T& data) {
		using mybst::search_In;
		return search_In(this->_root, data, _hot = nullptr);
	}

	template<typename T>
	BinNode<T>*& BST<T>::search(const T& data) {
		if (!this->_root || data == this->_root->_data) {//如果根节点不为空，或者正好根节点就是要找的节点
			_hot = nullptr;
			return this->_root;
		}
		_hot = this->_root;//更新_hot

		while (true){
			//current的地址与_hot的孩子绑定，不能与_hot绑定。
			BinNodePtr& current = ((data < _hot->_data) ? _hot->_lchild : _hot->_rchild);
			if (!current || data == current->_data)
				return current;
			_hot = current;//更新_hot位置
		}
	}

	//=================插入================//
	template<typename T>
	BinNode<T>* BST<T>::insert(const T& data) {
		BinNodePtr& x = search(data);//查找有无这个节点//必须用引用，这样其才必然是_hot的孩子
		if (x)//若有，则返回这个节点，插入失败
			return x;
		x = new BinNode<T>(data, _hot);//若无，则新建一个节点，并将_hot节点作为其父节点连接到树上
		this->_size++;//更新规模
		this->updateHeightAbove(x);//更新高度。
		return x;
	}

	//=================删除================//
	template<typename T>//适用于AVL Splay,RedBlack等，必须这么设计，才能做到完美删除，且保持BST的性质
	static BinNode<T>* removeAt(BinNode<T>*& x, BinNode<T>*& hot) {//这里x必须用引用，才不会使指针乱指
		using BinNodePtr = BinNode<T>*;								

		//记录x的地址里面保存的值，若删除temp里面的值，即删除x里面的值，但x的本身地址不会影响temp，反之亦然。
		BinNodePtr temp = x;

		//替代被删除节点的接替者，一般为被删除节点的左孩子或者右孩子，而不是x的左孩子或者右孩子
		BinNodePtr replacer = nullptr;

		if (!HasLChild(x)) {//如果x没有左孩子，或者x左右孩子均无，则将x的右孩子作为x，并将接替者设为x的右孩子
			x = x->_rchild;
			replacer = x;
		}
		else if (!HasRChild(x)) {//如果x没有右孩子，则将x的左孩子作为x，并将接替者设为x的左孩子
			x = x->_lchild;
			replacer = x;
		}
		else {
			temp = temp->succ();//取得中序遍历的后继//这个后继必将没有左孩子
			std::swap(x->_data, temp->_data);//交换对应的值
			if (temp->_parent == x) {//如果后继的父亲是原来的x，后继必然为x的右孩子
				replacer = temp->_rchild; //就将后继的右孩子作为父亲的右孩子
				temp->_parent->_rchild = replacer;
			}
			else {//如果后继的父亲不是原来的x，后继必然为某一节点的左孩子
				replacer = temp->_rchild;
				temp->_parent->_lchild=replacer;//就将后继的右孩子作为这个节点左孩子
			}
		}
		//hot即被删除节点的父亲。而temp正是要删除的节点。
		hot = temp->_parent;
							
		if (replacer)//若replacer存在，则必须将其父指针指向hot。不然如同x->_rchild的父亲指向的还是原来的
			replacer->_parent = hot;
		
		//释放原来x所指的堆区的数据，或者x的后继的堆区的数据
		release(temp->_data);
		release(temp);

		return replacer;
	}

	template<typename T>
	bool BST<T>::remove(const T& data) {
		BinNodePtr& x = search(data);//接收返回的值，这里用引用
		if (x == nullptr)//若没找到
			return false;//返回false
		removeAt(x, _hot);//删除找到的节点
		this->_size--;//更新规模
		this->updateHeightAbove(_hot);//更新高度
		return true;
	}
}//namespace mytree

四、BST测试代码~

在此处，就会利用到再本系列文章第一部分中的遍历函数，以及利用仿函数来实现遍历。

#include<iostream>
#include "BinNode.h"
#include "BST.h"
using namespace std;
using namespace mytree;

template<typename BinNodePtr>
void visitprint(BinNodePtr x) {
	cout << x->_data;
}

int main() {

	BST<int>* BT = new BST<int>;
	//cout << BT.size() << endl;
	//cout << BT.empty() << endl;
	BT->insert(3);
	BT->insert(6);
	BT->insert(2);
	BT->insert(4);
	BT->insert(5);
	BT->insert(1);
	BT->insert(7);
	BT->insert(8);
	BT->remove(7);
	BT->remove(6);
	BT->remove(3);
	cout << endl;

	BT->travLevel(visitprint<BinNode<int>*>);
	cout << endl;

	BT->travPre(visitprint<BinNode<int>*>);
	cout << endl;

	BT->travIn(visitprint<BinNode<int>*>);
	cout << endl;

	BT->travPost(visitprint<BinNode<int>*>);
	cout << endl;

	delete BT;
	return 0;
}

结果为
42815
42185
12458
12584

在这里插入图片描述
动图演示为
在这里插入图片描述

五、BST的缺点~

  平均BST树的高度为log2n，即平均复杂度为log2n。而BST在高度上，并没有限制，因此可能出现这种情况。
在这里插入图片描述
  这样，要找到6这个节点，就需要把整棵树都遍历一遍，因此最坏复杂度为O(n)。这样BST相对有序的vector而言，就没有任何的优势。
  而这，也恰恰是我们要引入AVL和RedBlack的原因！

五、后序文章链接~

  1. 基本二叉树节点，通用函数 二叉树节点
  2. 基本二叉树类的定义和实现 二叉树基类
  3. BST（二叉搜索树的实现） BST
  4. AVL（二叉平衡搜索树的实现）AVL
  5. B树的实现（如果你只想了解B树，可以跳过所有章节，直接看B树）B树
  6. 红黑树的实现 RedBlack

学一个东西，不知道其道理，不高明！

天翔龙闪
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树的C++实现（只实现插入操作）
11-04
实现了红黑树的插入操作，删除操作太复杂未实现。数据量比较大，根据需要可在main中修改测试数据
树-二叉查找树与红黑树 c++
会说话的肚子的学习轨迹
01-30 527
二叉查找树： 1.若左子树非空，则左子树所有结点小于根结点。 2.若右子树非空，则右子树所有结点大于根结点。 3.其左右子树也为二叉查找树。 二叉排序树可用作字典，也可做优先队列。其主要支持的操作有：Search，Insert，Delete。这三个操作的时间复杂度都与树高有关，为O(h)。但由于插入顺序的不同，二叉树的构造也不同，若按从小到大插入或从大到小插入，则二叉树将退化为链表，其三个
红黑树
wangdass
04-23 125
介绍    红黑树是一种自平衡二叉查找树，是一种扩充的BST，它可以在O(log⁡2n\log_2{n}log2​n)时间进行查找，插入，和删除等操作。主要是对内存中，比较小规模的数据进行索引。 性质 颜色特征: 结点是红色或者黑色的; 根特征: 根结点永远是黑色的; 外部特征: 扩充外部的叶子结点是空的,颜色为黑; 内部特征: 红色结点的两个子结点都是黑色的,不允许两个连续的红色结点; 深...
利用BST性质建立二叉树 C++实现
Artorias的博客
11-28 417
特殊二叉树的建立（二叉搜索树） 首先我们先认识一下二叉搜索树(BST)，即任意节点的左节点肯定比该节点小，右节点比该节点大。然后当你中序遍历这棵树的时候，你会惊讶的发现遍历后得到的data是从小到大排序的。 给出如下一颗二叉搜索树： 中序遍历结果就是1 4 5 6 8 9 13 因此对于一个二叉搜索树的建立，只需要判断当前结点的data值和要插入的data值，如果data<root - &...
c++红黑树
www_zxf_csdn123的博客
06-12 85
什么是红黑树？ 也是一种二叉搜索树，但是每个结点上增加一个存储位表示结点的颜色，可以是RED或BLACK，它是接近平衡的 红黑树的性质也是很关键的 1）每个结点不是红的就是黑的 2）每条路径上黑色的数量必须相等 3）根结点必须是黑的 4）两个红色的不能连续 5）每个叶子结点都是黑的（指的是空节点） 思考题1 在节点的定义中，为什么要将节点的默认颜色给成红色的？ 答：因为要保证每条路径上黑色结点数目...
二叉树-基于C++实现的二叉搜索树.zip
最新发布
04-26
总之，二叉搜索树是一种重要的数据结构，它在C++中的实现涉及到节点结构的设计和插入、查找、删除等操作的实现。理解并掌握二叉搜索树的原理和操作是提升算法能力的关键，而自平衡二叉搜索树则进一步提高了在大规模...
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
二叉搜索树（Binary Search Tree, BST）是一种特殊的二叉树结构，它的每个节点都包含一个键值（key）、一个指向左子树的指针和一个指向右子树的指针。在二叉搜索树中，对于任意节点，其左子树中的所有节点的键值都...
BST.rar_二叉搜索树
09-14
二叉搜索树（Binary Search Tree，简称BST），是一种特殊的二叉树数据结构，它具有以下特性：对于任意一个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中所有节点的值都大于该节点的值。这个特性使得...
BST.rar_binary search tree_二叉搜索树
09-19
二叉搜索树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉搜索树中，对于任意节点，其左子树中的所有...
BST_fanli.zip.二叉搜索树源码
04-10
二叉搜索树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的指针和一个指向右子树的指针。在二叉搜索树中，对于任何一个节点，其左子树中的...
红黑树C++实现
Cross
05-23 807
完整实现了一遍红黑树，程序就当作自己的笔记好了红黑树，顾名思义，就是红黑相间的树，它借由红黑规则实现了二叉树的平衡。红黑规则如下：1.每个节点不是红就是黑2.根总是黑色3.若节点为红色，它的子节点必须为黑色4.从根到叶的每条路径，必须包含相同数目的黑色节点插入和删除节点时都要遵循红黑规则，具体表现如下：1.首先所有新插入的节点都为红色2.若新插入的节点的父节点为红色，则必须对红黑树进行调整（1）旋...
二叉查找树BST和红黑树，果然。。。
兴华的博客
11-04 1616
红黑树是一种可以自平衡的二叉查找树；
BST的实现
江东小熊熊
10-26 293
//--------------------BST.h--------------------------- #include #ifndef BINARY_SEARCH_TREE #define BINARY_SEARCH_TREE template class BST { public: BST(); bool empty() const; bool search(co
C语言二叉树搜索（BST）相关练习
小鼻涕泡儿zZ的博客
01-29 442
最近学习了二叉搜索树的相关知识，练习写了关于为二叉搜索树实现一个抽象数据类型（ADT）的树（BST）。 BST以有序的方式存储密钥（左边的“更小”，右边的“更大的”根节点的权利）。 ADT的用户如何定义“更小”和“更大”界定。 没有关键词（key words）可以被存储两次，这里使用的BST不存储特定的类型，而是存储空间块指针。 比较两个不同的内存块的方式，比较或排序，是通过一个用户提供的功能，与
数据结构索引题库
闲狗的博客
08-02 4348
网络课课后题 1、设有一个职工文件，并设该文件由教材中表10-1所示的5个记录组成，其中职工号为关键码。 如下结构是什么类型的索引？ A、多分树静态索引 B、倒排索引 C、动态索引 D、线性索引 2、红黑树是一种扩充的二叉搜索树（BST）。给定一颗结点个数为n的红黑树在最坏的情况下，红黑树的删除结点操作的时间复杂度是O(log n) 3、设有一棵阶m=3的B树，如图10...
七、【数据结构】二叉搜索树(bst)的解析与实现
天涯明月刀的博客
12-09 600
本文使用C++实现二叉搜索树（binary search tree，bst）数据结构。 一、为什么要引入二叉搜索树 通过对向量和列表这两类线性数据结构的原理分析，我们可以发现向量结构在对静态查询操作的支持比较好，有序向量的二分查找能做到在O(logn)的时间，但是对删除和插入操作在最坏情况下能达到O(n)的时间。而与向量相对立的列表结构能很好地支持动态操作，如删除和插入只需要O(1)的时间，但...
二叉排序树(BST)：建立，遍历（前中后），判定，查找（递归+非递归）
王老大
10-15 1050
#include using namespace std; int g_min = -1; // BST的结点 typedef struct node { int key; struct node *lChild, *rChild; }Node, *BST; // 在给定的BST中插入结点，其数据域为element, 使之称为新的BST bool BSTInsert(Node * &p,
红黑树算法原理（从二叉搜索树讲起）
login_sonata的博客
08-05 4574
原文：红黑树深入剖析及Java实现，本文修改了原文的一些小错误，如果想看红黑树的Java实现可以到原文去看。 红黑树是平衡二叉查找树的一种。为了深入理解红黑树，我们需要从二叉查找树开始讲起。BST二叉查找树（Binary Search Tree，简称BST）是一棵二叉树，它的左子节点的值比父节点的值要小，右节点的值要比父节点的值大。它的高度决定了它的查找效率。在理想的情况下，二叉查找树增删查改的时
【C++】二叉搜索树（BST）
taoxing
07-11 782
一.基本介绍 特征： 二叉搜索树，也被称为二叉查找树、有序二叉树或者排序二叉树。 ∙\bullet∙ 一般来说输入的第一个数作为根结点，当继续输入数时，小于根结点的放在根结点左边，大于根结点的放在根结点右边。 ∙\bullet∙ 不只是根结点，每个子节点也符合左小右大的规律。 ∙\bullet∙ 如下图所示，输入数据8、3、10、1、6、14、4、7、13，得到下面的二叉搜索树。 下面我们来介绍BST的构成成分： ∙\bullet∙ 首先我们需要实现两个类：一个是BSTNode类（节点类）、一个为
平衡搜索树详解：从二叉搜索树到红黑树
"这篇文档由小组成员张晓丹、徐兵兵、马喜刚和张稳龙共同讨论，主要介绍了平衡搜索树的概念，包括平衡二叉搜索树（AVL树）和红黑树，旨在解决二叉搜索树查找效率低下的问题。" 平衡搜索树是一种特殊的二叉树数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值