【数据结构】二叉搜索树

已于 2023-09-14 17:29:38 修改
阅读量515 收藏 9
点赞数 10
分类专栏： 数据结构 文章标签： 数据结构 二叉搜索树 笔记
于 2023-07-31 18:10:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shun_Hua/article/details/132023524
版权

文章目录

前言

 普通的二叉树是不能进行增删改查的,或者说没意义，需要根据二叉树的某种性质，使之具有可利用的性质，那二叉搜索树是根据两数比较，除去相等外，只有大小之分的性质再结合二叉树的特点，演化出来的树, 顾名思义，就用来搜索的二叉树。

一、概念

树的概念：

二叉树——理论篇

二叉搜索树的概念：

  • 根节点的非空左子树，都比根节点小，根节点的非空右子树，都比根节点大。

细节：

  • 二叉搜索树可以为空。
  • 二叉搜索树的值互不相同（实现插入值时需要用到）。

图解：
在这里插入图片描述

瞧，这就是一颗二叉搜索树。

 概念其实不难理解，重点在于实现。

二、实现

1.基本说明

①要点

  • 为了便于理解，我们这里先将框架给出，再对其接口进行讲解。
  • 最后我给出源码。

②基本框架

//二叉树结点
template<class K>
struct BSTNode
{
	BSTNode(const K& key)
	{
		_key = key;
		_left = nullptr;
		_right = nullptr;
	}
	K _key;
	BSTNode* _left;
	BSTNode* _right;
};
//说明：二叉树结点是公用的，所以我们用struct(默认成员为公有)

//搜索二叉树的基本框架
template<class K>
class BSTree
{
public:
	typedef BSTNode<K> BSTNode;
	//增
	bool Insert(const K& key);
	//查
	BSTNode* find(const K& key);
public:
	//打印二叉搜索树
	void Print();
	//删
	bool Erase(const K& key);
private:
	void InOrder(BSTNode* root);

	BSTNode* _root = nullptr;
};

2.接口实现

①find——查找二叉树的结点

功能：找到就返回二叉树结点，没找到就返回空指针。

实现原理：根据根节点的左边比根节点小，右边比根节点大，如果要查找的值比根节点大，说明在根节点的右边，否则在左边。

在此之前，我们还要讨论一个小问题，你觉得二叉搜索树的查找的时间复杂度是多大呢？

答案：在O(logN)和O(N)之间。

结合满二叉树的最好情况，和形状类似单链表的最坏情况，仔细思考一下是不是这样？

实现代码:

  • 非递归版本
	//查找
	BSTNode* find(const K& key)
	{
		BSTNode* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				//目标值比根节点小，到左子树进行查找
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				//目标值比根节点大，到右子树进行查找
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}
  • 递归版本
BSTNode* _find(BSTNode* root, const K& key)
{
	if (root == nullptr)
	{
		return nullptr;
	}

	if (root->_key > key)
	{
		//到左子树进行查找
		return _find(root->_left, key);
	}
	else if (root->_key < key)
	{
		//到右子树进行查找
		return _find(root->_right, key);
	}
	else
	{
		return root;
	}
}
BSTNode* find(const K& key)
{
	return _find(_root, key);
}

②Insert——插入结点

原理分析：

  • 先找到空位置，通过搜索二叉树的定义，找到合适的位置，然后再将节点进行插入即可。

细节：

  • 当树为空时，直接改变根节点即可。

  • 插入时，需要先保存父节点，是对父节点的对应子节点进行插入，而不是对子节点的拷贝进行插入。

  • 非递归
    非递归博主给出两种写法,喜欢哪种写哪一种。
    1 . 第一种写法：保存父节点的位置，最后进行判断。

	bool Insert(const K& key)
	{
		//如果根节点为空，那就在根节点插入即可。
		if (_root == nullptr)
		{
			_root = new BSTNode(key);
		}
		else
		{
			BSTNode* cur = _root;
			BSTNode* parent = nullptr;
			while (cur)
			{

				if (cur->_key < key)
				{
					//先保存父节点的位置
					parent = cur;
					//根节点的值小于key，在右子树查找位置。
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					//先保存父节点的位置
					parent = cur;
					//根节点的值大于key，在左子树查找位置
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}
			//这里是根据父节点的位置，找到指定插入结点。

			if (parent->_key > key)
			{
				//在左边进行插入
				parent->_left = new BSTNode(key);
			}
			else
			{
				//在右边进行插入
				parent->_right = new BSTNode(key);
			}
		return true;
	}

  2 . 第二种写法：使用二级指针，无需保存父节点。

bool Insert(const K& key)
{
	//如果根节点为空，那就在根节点插入即可。
	if (_root == nullptr)
	{
		_root = new BSTNode(key);
	}
	else
	{
			BSTNode** cur = &_root;
			while(*cur)
			{
				if ((*cur)->_key > key)
				{
					cur = &((*cur)->_left);
				}
				else if ((*cur)->_key < key)
				{
					cur = &((*cur)->_right);
				}
				else
				{
					return false;
				}
			}
			*cur = new BSTNode(key);
	}
	return true;
}
  • 递归版本
bool _Insert(BSTNode*& root, const K& key)
{
	if (root == nullptr)
	{
		root = new BSTNode(key);
		return true;
	}

	if (root->_key > key)
	{
		//到左子树进行查找
		return _Insert(root->_left, key);
	}
	else if (root->_key < key)
	{
		//到右子树进行查找
		return _Insert(root->_right, key);
	}
	else
	{
		return false;
	}
}
bool Insert(const K& key)
{
	return _Insert(_root, key);
}

③Print——中序遍历打印二叉树的值

  • 说明：二叉搜索树中序遍历为升序。

这没啥好说的，很简单。

	void InOrder(BSTNode* root)
	{
		if (root == nullptr)
		{
			return;
		}
		InOrder(root->_left);
		cout << root->_key << " ";
		InOrder(root->_right);
	}
	void Print()
	{
		InOrder(_root);
		cout << endl;
	}

细节：

  • 如果不写一个中序遍历，Print是需要传一个根节点的，而外面是无法知道根节点的，因此需要我们在里面套一层。

④Erase——删除结点

  • 这是实现搜索二叉树的关键接口。

实现原理：

  • 第一步 ：先找到要删除的结点，没有返回false。
  • 第二步：找到之后分类进行讨论，由于结点可能会有分支，所以还要保留其父节点，为了便于理解，这里的删除情况，博主细分成了四种，下面一 一讲解。
情况细分
  1. 第一种情况：结点的左右结点为空

特殊情况：
在这里插入图片描述

  • 删除1，但父节点也是1，直接将根节点置为空即可。

在这里插入图片描述
说明：要删除5。

很简单，父节点指向空即可。

  1. 第二种情况:结点的左结点为空

特殊情况:
在这里插入图片描述

说明：删除 1

  • 当前结点与根节点相同，直接将根节点改为根节点的右结点。

在这里插入图片描述
说明：删除 5

  • 很简单，直接将父节点——4，指向5的右结点即可。
  1. 第三种情况：结点的右结点为空

特殊情况：
在这里插入图片描述
说明：删除 1

  • 结点与根节点相同，将根节点改为根节点的左结点。

在这里插入图片描述
说明：删除 0

  • 将父节点——1 ，指向结点——0的左节点。
  1. 第四种情况：结点的左右结点都不为空

采用方法——置换法，即找到结点左子树中最大的结点（leftMax），然后与结点的值进行交换，最后删除leftMax即可。（找到右子树最小的结点也可以，道理相同，就不赘述了）

特殊情况：
在这里插入图片描述

说明：删除 1

  • 这里结点——1 的左子树最大的为结点——0（leftMax），我们需将其值进行交换，然后将leftMax的父节点的左结点指向leftMax的左结点。

在这里插入图片描述
说明：删除 1

  • 找结点 —— 1的左子树的最大结点—— -1所在结点（leftMax），将其值进行交换，然后将leftMax的父节点的右结点指向leftMax的左结点。

情况分析完毕，代码实现就很简单了：

  • 非递归版本
bool Erase(const K& key)
{
	//大体上分为两种情况：
	//第一种情况：所删除结点左右结点至少有一结点为空——细分有三种情况
	//第二种情况: 所删除结点左右结点都不为空——细分只有一种情况

	//先找结点
	BSTNode* cur = _root;
	BSTNode* parent = _root;
	while (cur)
	{
		if (cur->_key > key)
		{
			parent = cur;
			//到左子树进行查找
			cur = cur->_left;
		}
		else if (cur->_key < key)
		{
			parent = cur;
			//到右子树进行查找
			cur = cur->_right;
		}
		else
		{
			//找到了

			//分情况进行删除

			//第一种情况：cur左右结点都为空
			if (!(cur->_left || cur->_right))
			{
				if (cur == _root)
				{
					_root = nullptr;
				}
				else
				{
					//判断父节点的左节点是cur，还是右节点为cur。
					if (parent->_left == cur)
					{
						//让父节点指向cur的right
						parent->_left = nullptr;
					}
					else
					{
						parent->_right = nullptr;
					}
				}
			}
			//第二种情况:所删除结点左边为空
			else if (cur->_left == nullptr)
			{
				if (cur == _root)
				{
					_root = _root->_right;
				}
				else
				{
					//判断父节点的左节点是cur，还是右节点为cur。
					if (parent->_left == cur)
					{
						//让父节点指向cur的right
						parent->_left = cur->_right;
					}
					else
					{
						parent->_right = cur->_right;
					}
				}

				delete cur;
			}
			//第三种情况：所删除的右结点为空。
			else if (cur->_right == nullptr)
			{
				if (cur == _root)
				{
					_root = _root->_left;
				}
				else
				{
					//判断父节点的左节点是cur，还是右节点是cur
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
			}
			//第四种情况：左右结点都不为空
			else
			{

				//思路：找到左子树最大的结点，值进行交换，
				//删除交换后的leftMax。
				BSTNode* leftMax = cur->_left;
				//找到最大节点
				BSTNode* parent = cur;
				while (leftMax->_right)
				{
					parent = leftMax;
					leftMax = leftMax->_right;
				}
				//找到，值进行交换，不能是结点！
				swap(leftMax->_key, cur->_key);

				//交换完删除leftMax

				if (parent == cur)
				{
					parent->_left = leftMax->_left;
				}
				else
				{
					parent->_right = leftMax->_left;
				}
				delete leftMax;
			}
			return true;
		}
	}
	return false;
}
  • 递归版本
bool Erase(const K& key)
{
	return _Erase(_root, key);
}
bool _Erase(BSTNode*& root, const K& key)
{
	if (root == nullptr)
	{
		return false;
	}

	if (root->_key > key)
	{
		return _Erase(root->_left, key);
	}
	else if (root->_key < key)
	{
		return _Erase(root->_right, key);
	}
	else
	{
		BSTNode* del = root;
		if (root->_left == nullptr)
		{
			root = root->_right;
		}
		else if (root->_right == nullptr)
		{
			root = root->_left;
		}
		else
		{
			//找到左子树最大的结点
			BSTNode* leftMax = root->_left;
			while (leftMax->_right)
			{
				leftMax = leftMax->_right;
			}

			//交换值
			swap(leftMax->_key, root->_key);

			//删除左子树的key值结点
			return _Erase(root->_left, key);
		}
		delete del;
	}
	return true;
}

源码

  • 非递归
#include<iostream>
using namespace std;

template<class K>
struct BSTNode
{
	BSTNode(const K& key)
	{
		_key = key;
		_left = nullptr;
		_right = nullptr;
	}
	K _key;
	BSTNode* _left;
	BSTNode* _right;
};

template<class K>
class BSTree
{

public:
	typedef BSTNode<K> BSTNode;
	typedef BSTNode** BSTPtr;
	typedef BSTNode* BSTPtr1;
	//增
	bool Insert(const K& key)
	{
		//如果根节点为空，那就在根节点插入即可。
		if (_root == nullptr)
		{
			_root = new BSTNode(key);
		}
		else
		{
			//第一种写法：
			//根据搜索二叉树的性质：左边都比跟结点小，右边都比根节点大，
			//找到空位置进行插入即可。

			BSTNode* cur = _root;
			BSTNode* parent = nullptr;
			while (cur)
			{

				if (cur->_key < key)
				{
					//先保存父节点的位置
					parent = cur;
					//根节点的值小于key，在右子树查找位置。
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					//先保存父节点的位置
					parent = cur;
					//根节点的值大于key，在左子树查找位置
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}
			//这里是根据父节点的位置，找到指定插入结点。

			if (parent->_key > key)
			{
				//在左边进行插入
				parent->_left = new BSTNode(key);
			}
			else
			{
				//在右边进行插入
				parent->_right = new BSTNode(key);
			}


			//第二种写法：二级指针

			//BSTNode** cur = &_root;
			//while(*cur)
			//{
			//	if ((*cur)->_key > key)
			//	{
			//		cur = &((*cur)->_left);
			//	}
			//	else if ((*cur)->_key < key)
			//	{
			//		cur = &((*cur)->_right);
			//	}
			//	else
			//	{
			//		return false;
			//	}
			//}
			//*cur = new BSTNode(key);
		}
		return true;
	}
	//查找
	BSTNode* find(const K& key)
	{
		BSTNode* cur = _root;
		while (cur)
		{

			if (cur->_key > key)
			{
				//目标值比根节点小，到左子树进行查找
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				//目标值比根节点大，到右子树进行查找
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}
private:
	void InOrder(BSTNode* root)
	{
		if (root == nullptr)
		{
			return;
		}
		InOrder(root->_left);
		cout << root->_key << " ";
		InOrder(root->_right);
	}
public:
	void Print()
	{
		InOrder(_root);
		cout << endl;
	}

	//改
	bool Erase(const K& key)
	{
		//大体上分为两种情况：
		//第一种情况：所删除结点左右结点至少有一结点为空——细分有四种情况
		//第二种情况: 所删除结点左右结点都不为空——细分只有一种情况

		//先找结点
		BSTNode* cur = _root;
		BSTNode* parent = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				//到左子树进行查找
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				//到右子树进行查找
				cur = cur->_right;
			}
			else
			{
				//找到了

				//分情况进行删除

				//第一种情况：cur左右结点都为空
				if (!(cur->_left || cur->_right))
				{
					if (cur == _root)
					{
						_root = nullptr;
					}
					else
					{
						//判断父节点的左节点是cur，还是右节点为cur。
						if (parent->_left == cur)
						{
							//让父节点指向cur的right
							parent->_left = nullptr;
						}
						else
						{
							parent->_right = nullptr;
						}
					}
				}
				//第二种情况:所删除结点左边为空
				else if (cur->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = _root->_right;
					}
					else
					{
						//判断父节点的左节点是cur，还是右节点为cur。
						if (parent->_left == cur)
						{
							//让父节点指向cur的right
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}

					delete cur;
				}
				//第三种情况：所删除的右结点为空。
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = _root->_left;
					}
					else
					{
						//判断父节点的左节点是cur，还是右节点是cur
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				//第四种情况：左右结点都不为空
				else
				{

					//思路：找到左子树最大的结点，值进行交换，
					//删除交换后的leftMax。
					BSTNode* leftMax = cur->_left;
					//找到最大节点
					BSTNode* parent = cur;
					while (leftMax->_right)
					{
						parent = leftMax;
						leftMax = leftMax->_right;
					}
					//找到，值进行交换，不能是结点！
					swap(leftMax->_key, cur->_key);

					//交换完删除leftMax

					if (parent == cur)
					{
						parent->_left = leftMax->_left;
					}
					else
					{
						parent->_right = leftMax->_left;
					}
					delete leftMax;
				}
				return true;
			}
		}
		return false;
	}
private:
	BSTNode* _root = nullptr;

};
  • 递归
	#include<iostream>
	using namespace std;
	template<class K>
	struct BSTNode
	{
		BSTNode(const K& key)
		{
			_key = key;
			_left = nullptr;
			_right = nullptr;
		}
		K _key;
		BSTNode* _left;
		BSTNode* _right;
	};
	template<class K>
	class BSTree
	{
	public:
		typedef BSTNode<K> BSTNode;
		//增
		bool _Insert(BSTNode*& root, const K& key)
		{
			if (root == nullptr)
			{
				root = new BSTNode(key);
				return true;
			}

			if (root->_key > key)
			{
				//到左子树进行查找
				return _Insert(root->_left, key);
			}
			else if (root->_key < key)
			{
				//到右子树进行查找
				return _Insert(root->_right, key);
			}
			else
			{
				return false;
			}

		}
		bool Insert(const K& key)
		{
			return _Insert(_root, key);
		}

		//查
		BSTNode* _find(BSTNode* root, const K& key)
		{
			if (root == nullptr)
			{
				return nullptr;
			}

			if (root->_key > key)
			{
				//到左子树进行查找
				return _find(root->_left, key);
			}
			else if (root->_key < key)
			{
				//到右子树进行查找
				return _find(root->_right, key);
			}
			else
			{
				return root;
			}
		}
		BSTNode* find(const K& key)
		{
			return _find(_root, key);
		}

	public:

		//打印二叉搜索树
		void Print()
		{
			InOrder(_root);
			cout << endl;
		}
		bool _Erase(BSTNode*& root, const K& key)
		{
			if (root == nullptr)
			{
				return false;
			}

			if (root->_key > key)
			{
				return _Erase(root->_left, key);
			}
			else if (root->_key < key)
			{
				return _Erase(root->_right, key);
			}
			else
			{
				BSTNode* del = root;
				if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else
				{
					//找到左子树最大的结点
					BSTNode* leftMax = root->_left;
					while (leftMax->_right)
					{
						leftMax = leftMax->_right;
					}

					//交换值
					swap(leftMax->_key, root->_key);

					//删除左子树的key值结点
					return _Erase(root->_left, key);
				}
				delete del;
			}
			return true;
		}
		//删
		bool Erase(const K& key)
		{
			return _Erase(_root, key);
		}
	private:
		void InOrder(BSTNode* root)
		{
			if (root == nullptr)
			{
				return;
			}
			InOrder(root->_left);

			cout << root->_key << " ";

			InOrder(root->_right);
		}

		BSTNode* _root = nullptr;
	};

总结

 今天的分享就到这里了，如果觉得文章不错，点个赞鼓励一下吧！我们下篇文章再见！

舜华丶
关注
  • 10
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
陈越、何钦铭-数据结构作业8：二叉搜索树的操作集
03-28
函数Insert将X插入二叉搜索树BST并返回结果树的根结点指针； 函数Delete将X从二叉搜索树BST中删除，并返回结果树的根结点指针；如果X不在树中，则打印一行Not Found并返回原树的根结点指针； 函数Find在二叉搜索树BST中找到X，返回该结点的指针；如果找不到则返回空指针； 函数FindMin返回二叉搜索树BST中最小元结点的指针； 函数FindMax返回二叉搜索树BST中最大元结点的指针。
javascript数据结构之二叉搜索树实现方法
10-23
主要介绍了javascript数据结构之二叉搜索树实现方法,较为详细的分析了二叉搜索树的概念、原理与JavaScript实现二叉搜索树的方法,对于学习JavaScript数据结构具有一定参考借鉴价值,需要的朋友可以参考下
数据结构 二叉搜索树
08-06
大二《数据结构》课程设计 二叉搜索树实现算法
陈越、何钦铭-数据结构作业12：是否同一棵二叉搜索树
04-20
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。
数据结构-二叉搜索树
zgege的博客
06-15 215
二叉搜索数 AVL数 红黑树
数据结构 ： 二叉搜索树(BST)
LOOKTOMMER的博客
10-07 1224
????‍???? ????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍??????
数据结构——二叉搜索树
qq_42106610的博客
11-04 345
二叉搜索树的定义、性质及相关操作，分别用递归和非递归两种方法实现了插入、删除函数
数据结构_平衡二叉搜索树(AVL树)
xc13212777631的博客
06-21 8599
平衡二叉搜索树 在二叉搜索树中，已经知道search、insert和remove等主要接口的运行时间均正比于树的高度。但是在最坏的情况下，二叉搜索树可能退化成列表，此时查找的效率会降至O(n)。因此，通常通过控制树高，来控制最坏情况下的时间复杂度。 对于节点数目固定的BST，越是平衡，最坏情况下的查找速度越快，如下图所示： 为了理解平衡二叉树，我们首先要理解几个主要概念，理想平衡与适度平...
数据结构之二叉搜索树
求知若渴！大智若愚！
04-18 721
纸上得来终觉浅，绝知此事要躬行 性质对于节点x 如果y是x的左孩子，则x.key>=y.keyx.key >= y.key 如果y是x的右孩子，则x.key<=y.keyx.key <= y.key 如图1： 查询操作 遍历操作：inorder-tree-walk(x)——中序, preorder-tree-walk(x)——先序,postorder-tree-walk(x)——后续 inorde
【数据结构】搜索二叉树/map/set
zxf123567的博客
07-10 576
搜索二叉树/map/set/K模型/KV模型
深入理解二叉搜索树（BST）
热门推荐
雨的微笑
04-04 3万+
一棵二叉搜索树（BST）是以一棵二叉树来组织的，可以用链表数据结构来表示，其中，每一个结点就是一个对象，一般地，包含数据内容key和指向孩子（也可能是父母）的指针属性。如果某个孩子结点不存在，其指针属性值为空（NIL）。 二叉搜索树中的关键字key的存储方式总是满足二叉搜索树的性质： 设x是二叉搜索树中的一个结点。如果y是x左子树中的一个结点，那么会有y.key=x.key。 二
【数据结构】二叉搜索树——二叉搜索树的概念和介绍、二叉搜索树的简单实现、二叉搜索树的增删查改
最新发布
Crocodile1006的博客
09-06 2149
数据结构、二叉搜索树、二叉搜索树的概念和介绍、二叉搜索树的简单实现、二叉搜索树的插入、二叉搜索树的查找、二叉搜索树的遍历、二叉搜索树的删除、完整代码和测试
数据结构——搜索二叉树
weixin_67401157的博客
08-02 795
数据结构——搜索二叉树
二叉搜索树（BST-Tree）(C++全)
weixin_48560325的博客
04-28 4743
目录 二叉搜索树基本概念 1，什么是根节点 2、什么是二叉搜索树 3、二叉搜索树结构 4、二叉搜索树的性质 5、复杂度 算法实现 1、创建一个二叉搜索树节点 2、打印二叉搜索树 3、二叉搜索树的插入 4、其他操作 （1）查找二叉搜索树的最大值 （2）查找二叉搜索树的最小值 （3）查找某一节点的前驱 （4）查找某一节点的后继 5、删除二叉搜索树的某一节点 步骤： 代码： 性能分析 二叉搜索树基本概念 1，什么是根节点 根结点（root）是树的一个组成部分，也
数据结构 二叉搜索树的删除
小手挥墨
04-30 4270
文章目录概述待删除的结点没有子树待删除的结点仅有一颗子树待删除的结点有两颗子树C代码实现 概述 这是一篇短文，专门考究一下二叉搜索树的删除。 二叉搜索树的建立非常简单，如果不熟悉的见此文 树与二叉树。 而删除则有数种情况： 待删除的结点没有子树。 待删除的结点仅有一颗子树。 待删除的结点有两颗子树。 下面逐一分析。 待删除的结点没有子树 如需删除下图中结点9： 这是最简单的一种情况，它没有子...
看图轻松理解数据结构与算法系列(二叉搜索树)
weixin_34120274的博客
08-01 164
前言 推出一个新系列，《看图轻松理解数据结构和算法》，主要使用图片来描述常见的数据结构和算法，轻松阅读并理解掌握。本系列包括各种堆、各种队列、各种列表、各种树、各种图、各种排序等等几十篇的样子。 关于树 对于树的数据结构大家都了解，只是树的类型有很多，所以可能又会对树产生一种陌生感。树其实就是由有限n(n&gt;=1)个节点组成的一个具有层次关系的集合，它看起来像一棵倒挂的树，所以称之为“树”。 ...
数据结构-二叉搜索树 详解
HeartFireY的博客
06-06 2309
一、二叉搜索树 简介 二叉搜索树(BST, Binary Search Tree)是一种基于二叉树的树形数据结构，定义(满足的性质)如下 空树是二叉搜索树 若二叉搜索树的左子树不为空，则其左子树上所有点的权值均小于其根节点的权值； 若二叉搜索树的右子树不为空，则其右子树上所有点的权值均大于其根节点的权值； 二叉搜索树的左右子树均为二叉搜索树 不难发现，二叉搜索树是采用递归进行定
数据结构二叉搜索树avl树
04-12
二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树，它的左子树所有节点的关键值（键值）小于根节点的关键值，而右子树所有节点的关键值大于根节点的关键值。AVL树则是一种自平衡的二叉搜索树，它保证...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值