二叉搜索树

于 2022-12-28 11:57:11 发布
阅读量476 收藏
点赞数
分类专栏： C/C++ 文章标签： 数据结构 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/myscratch/article/details/128465632
版权

概念

二叉搜索树又称为二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：

· 若它的左子树不为空，则左子树上所有结点的值都小于根结点的值。
· 若它的右子树不为空，则右子树上所有结点的值都大于根结点的值。
· 它的左右子树也分别是二叉搜索树。
如下所示，是一颗二叉搜索树
请添加图片描述

  • 特点：
    二叉搜索树以中序遍历得到升序序列。

二叉搜索树实现

  • 构造函数：
    构造空树即可。
//构造函数
BSTree()
	:_root(nullptr)
{}
  • 拷贝构造：递归拷贝
    利用递归，去构造树的左右子树，每次返回当前节点，就能链接起来左右子树。
//拷贝树
Node* _Copy(Node* root)
{
	if (root == nullptr) //空树直接返回
		return nullptr;
	// 依次拷贝左右孩子
	Node* copyNode = new Node(root->_key); //拷贝根结点
	copyNode->_left = _Copy(root->_left); //拷贝左子树
	copyNode->_right = _Copy(root->_right); //拷贝右子树
	return copyNode; //返回拷贝的树
}
//拷贝构造函数
BSTree(const BSTree<K>& t)
{
	_root = _Copy(t._root); //拷贝t对象的二叉搜索树
}
  • 赋值运算符重载：
    **现代写法：**拿来直接用
//现代写法
BSTree<K>& operator=(BSTree<K> t) //编译器接收右值的时候自动调用拷贝构造函数
{
	swap(_root, t._root); //交换这两个对象的二叉搜索树
	return *this; //支持连续赋值
}
  • 析构：
    递归地去释放
//释放树中结点
	void _Destory(Node* root)
	{
		if (root == nullptr) //空树无需释放
			return;

		_Destory(root->_left); //释放左子树中的结点
		_Destory(root->_right); //释放右子树中的结点
		delete root; //释放根结点
	}
	//析构函数
	~BSTree()
	{
		_Destory(_root); //释放二叉搜索树中的结点
		_root = nullptr; //及时置空
	}
  • 插入：非递归方式
  1. 如果是空树，直接插入节点作为二叉搜索树根节点。
  2. 如果不是空树，按照二叉搜索树性质进行节点插入。
  3. 依次把key和当前待插入节点做比较，待插入节点k较大，则插入到右子树，反之去遍历左子树，找到空位置就停下，说明到了可插位置。如果待插入节点值等于根节点值，则插入失败，因为已经存在。
  4. 来到空位置时，需要判断当前在父节点左边还是右边。

做法：

  1. 二叉树需要链接，所以需要父亲节点和当前cur节点，父亲初始置null，cur置root。
  2. 如果是根节点，直接创建新节点，然后返回true。
  3. 根据二叉搜索树性质，更新父亲和cur节点。
  4. 如果未经过返回说明到了合适位置，判断cur需要位于parent的左还是右。
bool Insert(const K& key, const V& value)
	{
		if (_root == nullptr)
		{
			_root = new Node(key, value);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
				return false;
		}

		// 若到此，说明cur到了空位置，可以插入，但不知道在父节点左还是右
		cur = new Node(key, value);
		// 对比看父的值和当前插入值比较 决定插在哪边 
		if (parent->_key < cur->_key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		return true;
	}
  • 查找：非递归查找
    用cur即可，根据BST的性质，key大，就找右，key小找左，返回值类型是Node*，相等时直接返回cur即可。
Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
				cur = cur->_right;
			else if (cur->_key > key)
				cur = cur->_left;
			else
				return cur;
		}
		return nullptr;
	}
  • 删除：
    非递归方式删除
    BST删除分为三种情况：
  1. 待删除结点的左子树为空。待删除结点左右子树均为空包含在内。
  2. 待删除结点的右子树为空。
  3. 待删除结点的左右子树均不为空。

做法：

  1. 需要使用两个指针parent、cur，因为有链接关系。
  2. 更新parent和cur到合适位置。

情况1：左子树为空，先判断待删节点是父亲的左儿子还是右儿子，然后让父亲直接链接到该节点的右子树。

情况2：右子树为空，先判断待删节点是父亲的左儿子还是右儿子，然后让父亲直接链接到该节点的左子树。

情况3：左右均不为空，寻找右子树的最小值，我们直接把右子树最小值位置删掉，让当前节点值为右子树最小节点。
然而这样的做法也有两种情况，如下两种：请添加图片描述

  1. 右子树最小节点值，是右子树的左孩子
  2. 右子树最小节点值是单支的。
bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		// 先找父和它
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			// 至此，找到了父亲和它：
			else
			{
				// 删除节点的左子树为空
				if (cur->_left == nullptr)
				{
					if (cur == _root)	// 所删为根节点
						_root = cur->_right;
					else	// 所删不为根节点
					{
						// 要判断所删是左孩子还是右孩子
						if (parent->_left == cur)
							parent->_left = cur->_right;
						else
							parent->_right = cur->_right;
					}
					delete cur;
					return true;
					// 每一分支需这两，因需停止.
				}
				else if (cur->_right == nullptr)	// 删除节点右子树为空
				{
					if (cur == _root)	// 所删为根
					{
						_root = cur->_left;
					}
					else  // 所删不为根
					{
						// 要判断所删是左孩子还是右孩子
						if (parent->_left == cur)
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}
					delete cur;
					return true;
					// 每一节分支都需这两，因需停止.
				}
				else   // 左右孩子都存在：找右子树中值最小的右节点，也就是右子树最左孩子
					// 让当前节点位置存最小右孩子，然后删除那个最小右孩子
				{
					Node* minParent = cur;	// 记录要删节点
					Node* minRight = cur->_right;	// 当前节点左右孩子都有，找右孩子最小，先确定当前右孩子
					// 寻找根节点右子树值最小节点
					while(minRight->_left)
					{
						// 一直往左走
						minParent = minRight;
						minRight = minRight->_left;
					}
					// 修改当前值，相当于删掉了当前节点
					cur->_key = minRight->_key;	// 不管右孩子有没有左孩子，这样都是对的。
					
					// 如果被删节点右孩子有树结构，经过循环，minP->left == minR 直接略过minR
					if (minRight == minParent->_left)
					{
						// minR可能有右孩子或没有右孩子，但是左边孩子一定没有了。
						minParent->_left = minRight->_right;
					}
					// 要删节点的右孩子就一个 或它的右孩子没有左孩子：是个部分右单支结构
					else
					{
						minParent->_right = minRight->_right;	// 直接链接右孩子的右指，当前cur已经变成原来的cur->right
					}
					delete minRight;
					return true;
				}
			}
		}
		return false;
	}

  • 遍历：（中序最经典的应用）
    遍历我们防止root节点暴露，所以直接用_Inorder来访问，然后外部只是调用_Inorder

  • 代码：

#include<iostream>
using namespace std;

//结点类
template<class K, class V>
struct BSTreeNode
{
	K _key;                 //结点值
	V _val;					
	BSTreeNode<K, V>* _left;   //左指针 
	BSTreeNode<K, V>* _right;  //右指针

	//构造函数
	BSTreeNode(const K& key = 0, const V& val = 0)
		:_key(key)
		,_val(val)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

template<class K, class V>
class BSTree
{
	typedef BSTreeNode<K, V> Node;
public:
	BSTree()
		:_root(nullptr) {};

	// 递归拷贝BST：每个递归，只创建一个节点，且返回，它的左右节点，都递归地链接起来。
	Node* _Copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;
		Node* copyNode = new Node();
		copyNode->_left = _Copy(root->_left);
		copyNode->_right = _Copy(root->_right);
		return copyNode;
	}

	BSTree(const BSTree<K, V>& t)
	{
		_root = _Copy(t._root);
	}

	/*
	插入：插入时刻需要两个节点 父节点和子节点
	找个合适位置，小于往左走 大于往右，等于就停止
	
	
	*/ 
	bool Insert(const K& key, const V& value)
	{
		if (_root == nullptr)
		{
			_root = new Node(key, value);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
				return false;
		}

		// 若到此，说明cur到了空位置，可以插入，但不知道在父节点左还是右
		cur = new Node(key, value);
		// 对比看父的值和当前插入值比较 决定插在哪边 
		if (parent->_key < cur->_key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		return true;
	}

	/*
	find：
	查找：大了给左边 小了给右边
	
	*/
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
				cur = cur->_right;
			else if (cur->_key > key)
				cur = cur->_left;
			else
				return cur;
		}
		return nullptr;
	}

	// 删除:
	/*
	删除之前 要先找该节点和父节点

	所删为叶：不用考虑，会包含在所删孩子无左或无右里面，情况合并直接干死
	此外，下面三种情况还要考虑：
		当前删的是不是根节点、当前所删节点在根的左还是右

	2. 有左孩子无右

	3. 有右孩子无左

	4. 左右孩子都有
	
	*/
	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		// 先找父和它
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			// 至此，找到了父亲和它：
			else
			{
				// 删除节点的左子树为空
				if (cur->_left == nullptr)
				{
					if (cur == _root)	// 所删为根节点
						_root = cur->_right;
					else	// 所删不为根节点
					{
						// 要判断所删是左孩子还是右孩子
						if (parent->_left == cur)
							parent->_left = cur->_right;
						else
							parent->_right = cur->_right;
					}
					delete cur;
					return true;
					// 每一分支需这两，因需停止.
				}
				else if (cur->_right == nullptr)	// 删除节点右子树为空
				{
					if (cur == _root)	// 所删为根
					{
						_root = cur->_left;
					}
					else  // 所删不为根
					{
						// 要判断所删是左孩子还是右孩子
						if (parent->_left == cur)
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}
					delete cur;
					return true;
					// 每一节分支都需这两，因需停止.
				}
				else   // 左右孩子都存在：找右子树中值最小的右节点，也就是右子树最左孩子
					// 让当前节点位置存最小右孩子，然后删除那个最小右孩子
				{
					Node* minParent = cur;	// 记录要删节点
					Node* minRight = cur->_right;	// 当前节点左右孩子都有，找右孩子最小，先确定当前右孩子
					// 寻找根节点右子树值最小节点
					while(minRight->_left)
					{
						// 一直往左走
						minParent = minRight;
						minRight = minRight->_left;
					}
					// 修改当前值，相当于删掉了当前节点
					cur->_key = minRight->_key;	// 不管右孩子有没有左孩子，这样都是对的。
					
					// 如果被删节点右孩子有树结构，经过循环，minP->left == minR 直接略过minR
					if (minRight == minParent->_left)
					{
						// minR可能有右孩子或没有右孩子，但是左边孩子一定没有了。
						minParent->_left = minRight->_right;
					}
					// 要删节点的右孩子就一个 或它的右孩子没有左孩子：是个部分右单支结构
					else
					{
						minParent->_right = minRight->_right;	// 直接链接右孩子的右指，当前cur已经变成原来的cur->right
					}
					delete minRight;
					return true;
				}
			}
		}
		return false;
	}

	// 为了不暴露root节点 
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_key<<" ";
		_InOrder(root->_right);
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

public:
	Node* _root;
};

void TestBSTree()
{
	/*BSTree<string, string> dict;
	dict.Insert("insert", "插入");
	dict.Insert("erase", "删除");
	dict.Insert("left", "左边");
	dict.Insert("string", "字符串");

	string str;
	while (cin >> str)
	{
		auto ret = dict.Find(str);
		if (ret)
		{
			cout << str << ":" << ret->_val << endl;
		}
		else
		{
			cout << "单词拼写错误" << endl;
		}
	}*/

	string strs[] = { "苹果", "西瓜", "苹果", "樱桃", "苹果", "樱桃", "苹果", "樱桃", "苹果" };
	// 统计水果出现的次
	BSTree<string, int> countTree;
	for (auto str : strs)
	{
		auto ret = countTree.Find(str);
		if (ret == NULL)
		{
			countTree.Insert(str, 1);
		}
		else
		{
			ret->_val++;
		}
	}
	countTree.InOrder();
}

调用：

#include"l5BST.h"

int main()
{
    BSTree<int, int> bst;
    bst.Insert(3, 1);
    bst.Insert(6, 1);
    bst.Insert(1, 1);
    bst.Insert(2, 1);

    bst.InOrder();
    cout << "删除 3" << endl;
    bst.Erase(3);
    bst.InOrder();
    cout << "字典BST" << endl;
    TestBSTree();
    return 0;
}

性能分析

对于一棵树，插入还是删除，都需要先查找，查找效率影响着其它的效率。
对于n个节点的二叉搜索树，
最优情况：二叉搜索树为完全二叉树， 我们比较树高次，logN的复杂度即可。
最差情况：二叉搜索树是单支，比较次数是N。

扩展：
B树和B+树是查找存储在磁盘当中的数据时经常用到的数据结构，B树系列对树的高度提出了更高的要求，普通二叉树不能满足要求，为降低树的高度，需要使用多叉树，而多叉树其实都是由二叉搜索树演变出来的，它们各有各的特点，适用于不同的场景。

知识点注意：

  1. 二叉搜索树一定是logN，错误，因为单支时退化为O(N)。
  2. 给定BST，根据节点值大小排序需要时间复杂度是线性的，因为中序是线性的。
  3. 给定一棵BST，线性时间内转为平衡二叉树,错误，因为经常涉及旋转等操作。
dfnsyyds
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉搜索树实例练习
09-05
二叉搜索树（Binary Search Tree，BST），是一种特殊的二叉树结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉搜索树中，对于任意节点： 1. 节点的左...
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
java实现 二叉搜索树功能
08-27
Java 实现二叉搜索树功能 二叉搜索树是一种特殊的二叉树，它的每个节点都含有一个Comparable的键值，且所有的键值都是唯一的，节点的键值也可以是基本类型，如int、long等，也可以是自定义的对象类型，只要实现了...
二叉搜索树的整理
WHITE ALBUM
07-04 286
二叉搜索树满足以下性质： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 因此，对于一个序列任意排序形成的二叉搜索树，中序遍历的结果唯一。二叉搜索树的基本操作：1.插入：比较插入点和当前点的键值，如果插入点小，递归当前点的左孩子，反之递归当前点的右孩子； 2
【数据结构】二叉搜索树
最新发布
Hello_World_213的博客
11-03 1132
二叉搜索树的概念及规则, 递归与非递归实现各种接口, 效率与稳定性分析
是否二叉搜索树
u013243314的专栏
06-25 5970
习题4.3 是否二叉搜索树   (25分) 本题要求实现函数，判断给定二叉树是否二叉搜索树。 函数接口定义： bool IsBST ( BinTree T ); 其中BinTree结构定义如下： typedef struct TNode *Position; typedef Position BinTree; struct TNode{ ElementType
二叉搜索树的查找、最值查找、插入和删除
大力海棠的博客
05-14 9654
对于一棵二叉搜索树，如果不为空，它应该满足以下三个特点：1、树上的任一结点，该结点的值都大于它的非空左子树的值。2、树上的任一结点，该结点的值都小于它的非空右子树的值。3、任一结点的左右子树都是二叉搜索树。对于二叉搜索树的查找，思路方法是：1、从根结点开始查找，如果树为空，就返回NULL。2、如果树不空，就让数据X和根结点的数据Data作比较。3、如果X的值大于根结点的Data，就往右子树中进行搜...
二叉树
热门推荐
Richard_Cai
09-19 5万+
二叉树的优势       在实际使用时会根据链表和有序数组等数据结构的不同优势进行选择。有序数组的优势在于二分查找，链表的优势在于数据项的插入和数据项的删除。但是在有序数组中插入数据就会很慢，同样在链表中查找数据项效率就很低。综合以上情况，二叉树可以利用链表和有序数组的优势，同时可以合并有序数组和链表的优势，二叉树也是一种常用的数据结构。二叉树的构成      二叉树由节点（node）和边组成。节点
深入理解二叉搜索树（BST）
雨的微笑
04-04 3万+
一棵二叉搜索树（BST）是以一棵二叉树来组织的，可以用链表数据结构来表示，其中，每一个结点就是一个对象，一般地，包含数据内容key和指向孩子（也可能是父母）的指针属性。如果某个孩子结点不存在，其指针属性值为空（NIL）。 二叉搜索树中的关键字key的存储方式总是满足二叉搜索树的性质： 设x是二叉搜索树中的一个结点。如果y是x左子树中的一个结点，那么会有y.key=x.key。 二
二叉排序树详解
William
03-26 3万+
前言博客编写人：Willam 博客编写时间：2017/3/25 博主邮箱：2930526477@qq.com（有志同道合之人，可以加qq交流交流编程心得）1、二叉排序树的介绍二叉排序树又称二叉查找树。二叉排序树有如下性质： 如果它的左子树不为空，那么左子树上的所有结点的值均小于它的根结点的值 如果它的右子树不为空，那么右子树上的左右结点的值均大于它的根结点的值 根结点的左子树和右子树又是二叉排序树。
二叉搜索树(二叉排序树)
爱敲代码的三毛的博客
09-09 4万+
一.概念 二叉搜索树又称二叉排序树，具有以下性质： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 注意：二叉搜索树中序遍历的结果是有序的 二、基本操作 1.查找元素 思路：二叉搜索树的左子树永远是比根节点小的，而它的右子树则都是比根节点大的值。当前节点比要找的大就往左走，当前元素比要找的小就往右走 public Node search(int key) { if(root ==

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值