二叉搜索树详解以及C++实现二叉搜索树（递归和非递归）

已于 2022-08-04 11:39:20 修改
阅读量811 收藏 5
点赞数 7
分类专栏： C++学习 文章标签： c++ 数据结构
于 2022-07-26 10:20:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61635026/article/details/125984867
版权
本文详细介绍了二叉搜索树的概念，包括其性质和构建示例，并重点讨论了插入、删除和查找这三个基本操作。提供了递归和非递归两种实现方式的C++代码，同时分析了二叉搜索树在不同情况下的性能，强调了平衡二叉搜索树如AVL树和红黑树对于优化性能的重要性。
摘要由CSDN通过智能技术生成

二叉搜索树详解以及C++实现二叉搜索树（递归和非递归）

1. 二叉搜索树的概念

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

  • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
  • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
  • 它的左右子树也分别为二叉搜索树
    例如：

2. 二叉搜索树的相关操作

以下列数组创建的搜索二叉树为例：

int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};

2.1 插入

插入的具体过程如下：

  1. 树为空，则直接新增节点，赋值给root指针。
  2. 树不空，按二叉搜索树性质查找插入位置，插入新节点。

例如：

2.2 删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：

  1. 要删除的结点无孩子结点。
  2. 要删除的结点只有左孩子结点。
  3. 要删除的结点只有右孩子结点。
  4. 要删除的结点有左、右孩子结点。

看起来有待删除节点有4中情况，实际情况 1 可以与情况 2 或者 3 合并起来，因此真正的删除过程如下：
情况2：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除。
情况3：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除。
情况4：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题–替换法删除。

例如：

2.3 查找

  1. 从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
  2. 最多查找高度次，走到到空，还没找到，这个值不存在。

3. 二叉搜索树的实现

3.1 创建结点

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;

	K _key;

	BSTreeNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{}
};

3.2 创建一个BSTree类

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
private:
	void DestoryTree(Node* root)
	{
		if (root == nullptr)
			return;
		DestoryTree(root->_left);
		DestoryTree(root->_right);
		delete root;
	}

	Node* CopyTree(Node* root)
	{
		if (root == nullptr)
			return nullptr;

		Node* copyNode = new Node(root->_key);
		copyNode->_left = CopyTree(root->_left);
		copyNode->_right = CopyTree(root->_right);

		return copyNode;
	}
public:
	BSTree() = default;//C++11、强制编译器自己生成构造函数

	BSTree(const BSTree<K>& t)
	{
		_root = CopyTree(t._root);
	}

	BSTree<K>& operator=(BSTree<K> t)
	{
		std::swap(_root, t._root);

		return *this;
	}

	~BSTree()
	{
		DestoryTree(_root);
		_root = nullptr;
	}
private:
	Node* _root = nullptr;
};

3.3 二叉搜索树的插入操作

3.3.1 递归实现

	bool _InsertR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}

		if (root->_key > key)
		{
			return _InsertR(root->_left, key);
		}
		else if (root->_key < key)
		{
			return _InsertR(root->_right, key);
		}
		else
		{
			return false;
		}
	}
	
	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}

3.3.2 非递归实现

	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			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 = new Node(key);
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		return true;
	}

3.4 二叉搜索树的删除操作

3.4.1 递归实现

	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
			return false;

		if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		else if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else
		{
			Node* del = root;

			if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else
			{
				Node* minRight = root->_right;
				while (minRight->_left)
				{
					minRight = minRight->_left;
				}

				swap(root->_key, minRight->_key);

				return _EraseR(root->_right, key);
			}
			delete del;
			return true;
		}
	}

	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}

3.4.2 非递归实现

	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{

				//一个孩子   左空/右空
				if (cur->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
				}
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				//两个孩子
				else
				{
					Node* minRight = cur->_right;
					Node* minParent = cur;
					while (minRight->_left)
					{
						minParent = minRight;
						minRight = minRight->_left;
					}
					//cur->_key = minRight->_key;
					swap(minRight->_key, cur->_key);
					if (minParent->_left == minRight)
					{
						minParent->_left = minRight->_right;
					}
					else
					{
						minParent->_right = minRight->_right;
					}
					delete minRight;
				}
				return true;
			}

		}
		return false;

	}

3.5 二叉搜索树的查找操作

3.5.1 递归实现

	bool _FindR(Node* root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			return _FindR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _FindR(root->_left, key);
		}
		else
		{
			return true;
		}
	}

	bool FindR(const K& key)
	{
		return _FindR(_root, key);
	}

3.5.2 非递归实现

	bool 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 true;
			}
		}
		return false;
	}

3.6 实现二叉搜索树的完整代码

#pragma once

#include<algorithm>
#include<iostream>
using namespace std;

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;

	K _key;

	BSTreeNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{}
};


template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;



public:
	BSTree() = default;//C++11、强制编译器自己生成构造函数

	BSTree(const BSTree<K>& t)
	{
		_root = CopyTree(t._root);
	}

	BSTree<K>& operator=(BSTree<K> t)
	{
		std::swap(_root, t._root);

		return *this;
	}

	~BSTree()
	{
		DestoryTree(_root);
		_root = nullptr;
	}

	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			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 = new Node(key);
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		return true;
	}

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

	bool 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 true;
			}
		}
		return false;
	}


	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{

				//一个孩子   左空/右空
				if (cur->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
				}
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				//两个孩子
				else
				{
					Node* minRight = cur->_right;
					Node* minParent = cur;
					while (minRight->_left)
					{
						minParent = minRight;
						minRight = minRight->_left;
					}
					//cur->_key = minRight->_key;
					swap(minRight->_key, cur->_key);
					if (minParent->_left == minRight)
					{
						minParent->_left = minRight->_right;
					}
					else
					{
						minParent->_right = minRight->_right;
					}
					delete minRight;
				}
				return true;
			}

		}
		return false;

	}

	bool FindR(const K& key)
	{
		return _FindR(_root, key);
	}


	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}

	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}

private:

	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
			return false;

		if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		else if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else
		{
			Node* del = root;

			if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else
			{
				Node* minRight = root->_right;
				while (minRight->_left)
				{
					minRight = minRight->_left;
				}

				swap(root->_key, minRight->_key);

				return _EraseR(root->_right, key);
			}
			delete del;
			return true;
		}
	}

	bool _InsertR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}

		if (root->_key > key)
		{
			return _InsertR(root->_left, key);
		}
		else if (root->_key < key)
		{
			return _InsertR(root->_right, key);
		}
		else
		{
			return false;
		}
	}

	void DestoryTree(Node* root)
	{
		if (root == nullptr)
			return;
		DestoryTree(root->_left);
		DestoryTree(root->_right);
		delete root;
	}

	Node* CopyTree(Node* root)
	{
		if (root == nullptr)
			return nullptr;

		Node* copyNode = new Node(root->_key);
		copyNode->_left = CopyTree(root->_left);
		copyNode->_right = CopyTree(root->_right);

		return copyNode;
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

	bool _FindR(Node* root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			return _FindR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _FindR(root->_left, key);
		}
		else
		{
			return true;
		}
	}


private:
	Node* _root = nullptr;
};

4. 二叉搜索树的应用

  1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
    比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
  2. KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：
    比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。

5. 二叉搜索树性能分析

二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

  • 最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其查找的时间复杂度为O(logN)。
  • 最差情况下，二叉搜索树退化为单支树(或者类似单支)，其查找的时间复杂度为O(N)。

如果想要二叉搜索树的性能都能达到最优，那么要实现AVL树和红黑树。

BriaGriffin
关注
专栏目录
【第91题】给定一个有序整数数组，元素各不相同且按升序排列，构造一棵高度最小的二叉搜索树
英雄哪里出来
09-12 2897
难度：★★★★☆，二叉搜索树的构造
中山大学十套数据结构试题及答案_加水印1
08-04
1. 栈和队列的共同特点是( ) 2. 用链接方式存储的队列，在进行插入运算时( 好久 ). 3. 以下数据结构中哪一个是非线性结构 4. 设有一个二维数组 A
给定一个有序整数数组，元素各不相同且按升序排列，编写一个算法，创建一棵高度最小的二叉搜索树
喝泉水的泉
11-20 586
/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ class Solution { public TreeNode sortedArrayToBST(int[] nums) { T...
建立二叉排序（搜索）树
Stillsings的博客
09-03 540
建立二叉排序（搜索）树 描述 输入一组数，对输入的数建立二叉树排序（搜索），并前中后序遍历二叉树。 28, 40, 20, 54, 66, 79 对待排序的数据进行排序 定义二叉树结构体，递归建立二叉树 递归前中后序遍历 定义二叉树节点结构体 struct TreeNode{ int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL){} };
二叉搜索树
H-rosy的博客
06-04 334
输入一系列整数，利用所给数据建立一个二叉搜索树，并输出其前序、中序和后序遍历序列。输入格式第一行一个整数 nn，表示输入整数数量。第二行包含 nn 个整数。输出格式共三行，第一行输出前序遍历序列，第二行输出中序遍历序列，第三行输出后续遍历序列。输入中可能有重复元素，但是输出的二叉树遍历序列中重复元素不用输出。数据范围1≤n≤1001≤n≤100, 输入元素取值范围 [1,1000][1,1000]。输入样例： 输出样例：......
适合小白学习的C++二叉排序树.doc
最新发布
05-29
查找节点的操作同样基于二叉排序树的性质，递归地搜索树： 1. 如果树为空或者当前节点的值等于查找的值，则返回该节点。 2. 如果待查找的值小于当前节点的值，则在左子树中查找。 3. 如果待查找的值大于当前节点的值...
C++的二叉排序树算法
11-10
### C++中的二叉排序树算法详解 #### 引言 在计算机科学中，二叉排序树...本篇文章通过分析一段具体的C++代码，深入浅出地介绍了二叉排序树的核心概念和实现细节，希望能帮助读者更好地理解和运用这一数据结构。
C++递归算法详解.docx
12-04
在实际应用中，递归可以解决多种问题，如树的遍历、图的搜索、动态规划等。然而，递归算法可能导致较高的时间和空间复杂度，因为每次递归调用都会占用内存，并且可能造成大量的重复计算。因此，理解并合理控制递归的...
C/C++递归技术详解
06-14
- **树和图的遍历**：在数据结构中，如二叉树和图，递归常用于遍历节点，例如深度优先搜索（DFS）和广度优先搜索（BFS）。 - **动态规划**：在解决具有重叠子问题和最优子结构的问题时，递归结合记忆化技术可以有效...
二叉搜索树的建立
Gary·hou专栏
03-23 3549
最近学习的数据结构。在树和二叉树中程序实现的很少。今天把二叉搜索树建立了，其实在二叉搜索树中插入和查找几乎是一样的。所以我为了更好的理解。在插入结点是我用非递归的实现。其实在非递归中还能很好的理解插入的过程。在查找中我就用了递归的方法。但是思路就没有非递归那样的清晰了，而删除函数我就没有写上去了，其实在学二叉树中我自己觉得在一些算法中还是很容易理解的。但是真正的编程实现就有一定的难度了，我这个
C++实现二叉树的创建以及四种遍历方式（递归与非递归）
weixin_42133358的博客
05-23 4860
C++实现二叉树的创建以及四种遍历方式（递归与非递归） 语言这个东西不用真的会忘， 我记得前前后后C++的基本语法我也看了好几遍了，一直没有动手写过什么东西，所以一遍遍的看，一遍遍的忘… … 正好最近在看数据结构，想着自己用C++来实现一下，一方面是熟悉整个逻辑过程，加深对数据结构的理解，另一方面，也熟悉一下C++。 下图是我们要创建的二叉树，其中的#代表空字符； 为了验证我们程序的正确性，现给出此二叉树的四种遍历结果： 前序遍历（Preorder traversal）： A B C D E F
C++ 不知树系列之二叉排序树（递归和非递归遍历、删除、插入……）
y6123236的专栏
11-04 1457
本文讲解了什么是二叉排序树，并深入地探讨在二叉排序树如何进行数据的插入、遍历、删除……
C++非递归创建二叉树及非递归遍历二叉树
qq_44055933的博客
04-01 716
【代码】C++非递归创建二叉树及非递归遍历二叉树。
二叉排序树的递归与非递归建立 C++实现
Changqing9的博客
12-11 178
#include <iostream> using namespace std; typedef struct Node{ int data; struct Node*lchild; struct Node*rchild; struct Node*par; }*BST; //递归建立二叉排序树 int Res_Creat(BST &root, int key) { if(root == NULL) { root = new Node; root->d.
c语言/c++（数据结构篇） 之 二叉树的操作实例（5/7）
qq_59819866的博客
06-29 591
后序遍历的遍历顺序为左孩子–>右孩子–>根节点，将这个顺序倒过来：根节点–>右孩子–>左孩子。但是，我们先不着急打印，利用栈结构能够使一段序列逆序的性质，将第一个栈中的节点全部放到第2个栈中去，那么打印顺序就发生了逆序：左孩子–>右孩子–>根节点，正好是后序遍历的顺序。先序遍历的遍历顺序为根节点–>左孩子–>右孩子，所以往栈中放数时先放右孩子，在放左孩子（左右孩子都不为空的情况下）。cout
二叉排序树 遍历 ACM 试题 C语言实现
thewebcode
03-13 331
// //题目描述： // 输入一系列整数，建立二叉排序数，并进行前序，中序，后序遍历。 // 输入： // 输入第一行包括一个整数n(1&lt;=n&lt;=100)。 // 接下来的一行包括n个整数。 // 输出： // 可能有多组测试数据，对于每组数据，将题目所给数据建立一个二叉排序树，并对二叉排序树进行前序、中序和后序遍历。 // 每种遍历结果输出一行。每行最后一个数据之后有一个空格。...
建立二叉排序树
qq_48321582的博客
01-11 1244
编写算法，输入一组整数，以9999为结束标志，将这些数据建立二叉排序树。输出中序排序序列检验是否为二叉排序树，并且在二叉排序树内查找值。 #include<iostream> using namespace std; struct BiNode { int key; int data; BiNode* lchild, * rchild; }; class BiSortTree { BiNode* root; void Insert(BiNode*& ptr, int k);
BUAA数据结构第五次作业2023
weixin_50567399的博客
05-19 6794
BUAA数据结构第五次上机作业
二叉搜索树详解及C++实现
"这篇资源提供了一份二叉搜索树的源码实现，包括基本操作如查找最小值、最大值、插入、删除以及不同顺序的遍历。" 二叉搜索树（Binary ...通过理解和实现二叉搜索树，可以更好地掌握动态数据结构的原理及其应用。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BriaGriffin

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值