二叉搜索树的实现

已于 2022-08-07 16:31:23 修改
阅读量523 收藏 3
点赞数 1
分类专栏： 数据结构 文章标签： 算法 数据结构
于 2022-07-31 11:28:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_64397669/article/details/126081453
版权

目录

1.二叉搜索树概念

2.二叉树插入的实现 

3. 二叉搜索树的查找

4.二叉树的删除

 5.二叉搜索树的应用

5.1 K模型

5.2 KV模型

1.二叉搜索树概念

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

2.二叉树插入的实现 

如何插入？

如果树为空，直接插入。
如果树不为空，则将要插入的值与二叉树中各结点的值比较，最后再插入

例如：

 代码实现：

先创建一个结构体存储每个结点的信息：

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

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

非递归版本：

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

递归版本： 

template<class K>
class BSTree
{
 typedef BSTreeNode<K> Node;
public:
     bool _InsertR(const K& key)
   {
	  return _InsertR(_root, key);
   }

private：
  	bool _InsertR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		if (key > root->_key)
		{
			return _InsertR(root->_right, key);
		}
		else if (key < root->_key)
		{
			return _InsertR(root->_left, key);
		}
		else//不允许存在相同的值
			return false;
	}
}
root是父亲结点的左右指针的引用，修改root也就是修改父亲结点的左右指针，

3. 二叉搜索树的查找 


  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;
		}
	}

4.二叉树的删除

二叉树的删除可分为两种情况。

1.要删除的结点只有一个孩子或无孩子。
2.要删除的结点有两个孩子。

例如：

 第一种情况：
    1.删除4；
    2.删除10；
  第二种情况：
    1.删除3；在它的右子树中寻找中序下的第一个结点(关键码最小，也就是最左结点)，用它的值填补到被删除 
             节点中，再来处理该结点的删除问题--替换法删除

 非递归版本

   bool Erase(const T& 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;
}

 当被删除的结点有两个孩子时：

Node* minParent = cur;
Node* minRight = cur->_right;
while (minRight->_left)
{
	minParent = minRight;
	minRight = minRight->_left;
}
swap(minRight->_key, cur->_key);

if (minParent->_left == minRight)
{
	minParent->_left = minRight->_right;
}
else
{
	minParent->_right = minRight->_right;
}

delete minRight;

 

 递归版本：

 public:
 bool EraseR(const K& key)
		{
			return _EraseR(_root, key);
		} 
private:
bool _EraseR(Node*& root, const K& key)//root是父亲结点左右指针的引用
	{
		if (root == nullptr)
			return false;

		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, 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;//找到被删删除结点的右孩子,minRight
				while (minRight->_left)//以minRight为根，找到最左的孩子。
				{
					minRight = minRight->_left;
				}

				swap(root->_key, minRight->_key);//将被删出的结点与最左孩子值替换。
				return _EraseR(root->_right, key);//此时被删除的结点在之前最左孩子的位置，它 
                                                     无左孩子，转换成了第一种情况对其删除。
			}
			delete del;
			return true;
		}
		
	}

 画图分析：

 完整代码：

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

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

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:
	// 强制编译器自己生成构造，C++11支持
	BSTree() = default;
	BSTree(const BSTree<K>& t)//写了拷贝构造，不会默认生成构造函数
	{
		_root = CopyTree(t._root);
	}

	BSTree<K>& operator=(BSTree<K> t)
	{
		swap(_root, t._root);
		return *this;
	}

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

    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);
  }

  void InOrder()
  {
     _InOrder(_root);
  }

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

		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, 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 (key > root->_key)
		{
			return _InsertR(root->_right, key);
		}
		else if (key < root->_key)
		{
			return _InsertR(root->_left, key);
		}
		else
			return false;
		
	}
	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;
		}
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}
private:
	Node* _root = nullptr;
};

 5.二叉搜索树的应用

5.1 K模型

K 模型即只有 key 作为关键码，结构中只需要存储 Key 即可，关键码即为需要搜索到 值 。
比如： 给一个单词 word ，判断该单词是否拼写正确 ，具体方式如下：
以词库中所有单词集合中的每个单词作为 key ，构建一棵二叉搜索树
在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误

5.2 KV模型

每一个关键码 key ，都有与之对应的值 Value ，即 <Key, Value> 的键值对 。
比如：
英汉词典就是英文与中文的对应关系 ，通过英文可以快速找到与其对应的中文，英
文单词与其对应的中文 <word, chinese> 就构成一种键值对；
或者统计单词等的次数，若存在，则把value的值+1；
对上面代码进行改进，来运用KV模型。
下面展示需要更改的部分 
template<class K, class V>
struct BSTreeNode
{
	BSTreeNode<K, V>* _left;
	BSTreeNode<K, V>* _right;

	const K _key;
	V _value;

	BSTreeNode(const K& key, const V& value)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
		, _value(value)
	{}
};
template<class K, class V>
class BSTree
{
	typedef BSTreeNode<K, V> Node;
public:

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

	Node* FindR(const K& key)//返回结点的指针，可对结点内容进行修改
	{
		return _FindR(_root, key);
	}

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


private:


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

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

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

		if (root->_key < key)
		{
			return _FindR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _FindR(root->_left, key);
		}
		else
		{
			return root;
		}
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_key << ":" << root->_value << endl;
		_InOrder(root->_right);
	}
private:
	Node* _root = nullptr;
};

例如：

void test2()
{
	string arr[] = { "香蕉","苹果","梨","桃子","梨","香蕉","黄瓜" };
		BSTree<string, int> p;
	for (auto ch : arr)
	{
		auto ret = p.FindR(ch);
		if (ret==nullptr)
		{
			p.InsertR(ch, 1);
		}
		else
		{
			ret->_value++;
		}
	}
	p.InOrder();
}
int main()
{
	test2();
	return 0;
}

结果：

黄瓜:1
梨:2
苹果:1
桃子:1
香蕉:2

二叉搜索树详解与实现
a1912157861的博客
01-09 758
二叉搜索树详解与实现二叉搜索树概念二叉树的增删查改K类型二叉搜索树和KV类型二叉搜索树的底层代码实现 二叉搜索树概念 二叉搜索树又称二叉排序树，它具有以下这几种性质: 如果它的左子树不为空，则左子树上所有节点的值都小于根节点的值 如果它的右子树不为空，则右子树上所有节点的值都大于根节点的值 他的左右子树都是二叉搜索树 那么它为什么要叫做二叉排序树呢？ 因为它的中序遍历就是一个有序的数列，所以我们一般用中序遍历来遍历二叉搜索树，并且也可以使用二叉搜索树的这个特性来检查当前二叉树是否是二叉搜索树。 二叉树的
基于二叉搜索树实现的电话簿程序
11-10
《基于二叉搜索树实现的电话簿程序》 在计算机科学中，数据结构是存储和组织数据的关键方式，而二叉搜索树（Binary Search Tree，BST）作为一种特殊的数据结构，因其高效的操作性能在各种实际应用中得到广泛使用。...
二叉搜索树实现
最新发布
m0_73573757的博客
03-14 849
我们曾经使用二分查找法在数组中找数，但是由于数组的地址空间是连续的，在对其进行数据的插入和删除时需要大量挪动数据，造成效率的损失；而如果在链表中找数，虽然进行数据的插入删除操作的效率大大提升，但查找的效率又变得很低，由此诞生了取二者长处的二叉搜索树。注意：二叉搜索树也可以是一颗空树。
二叉搜索树 的实现
qq_55164622的博客
09-23 357
什么是二叉搜索树？二叉搜索树有什么特性？二叉搜索树是怎样实现的？ （1）二叉搜索树 又称二叉查找树、二叉排序树，顾名思义二叉搜索树的查找效率非常的高，而且二叉搜索树要满足二叉树的结构特性故每个根节点最多只有两个叶子节点。这的二叉搜索树和前面学的堆的结构也是相似的。 ...
C#二叉搜索树插入算法实例分析
01-21
本文实例讲述了C#二叉搜索树插入算法。分享给大家供大家参考。具体实现方法如下： public class BinaryTreeNode { public BinaryTreeNode Left { get; set; } public BinaryTreeNode Right { get; set; } public...
javascript数据结构之二叉搜索树实现方法
11-24
在JavaScript中，我们可以创建一个二叉搜索树类来实现这些功能。以下是对标题和描述中提到的知识点的详细说明： 1. **二叉搜索树定义**： 二叉搜索树（Binary Search Tree，BST）的每个节点最多有两个子节点，分为...
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
【数据结构】二叉搜索树的实现
学了就忘是正常现象
01-23 2377
递归删除：找到节点后，同样需要分三种情况讨论。 1、被删除节点左树为空； 2、被删除节点左树不为空但右树为空； 3、被删除节点左右子树均不为空。
实现二叉搜索树
qq_43447509的博客
04-06 220
前言 二叉搜索树是二叉树的一种 每个节点的左子节点一定比自身小 每个节点的右子节点一定比自身大 实现思路和代码 实现二叉搜索树类 定义内部节点类 包含以下属性 key节点值 left指向左子节点 right指向右子节点 定义root属性表示根节点 function BinarySearchTree() { this.root = null function Node(key) { this.key = key this.left = null this.right
Java学习苦旅（二十三）——二叉搜索树
三人行必有我师
01-07 679
本篇博客将详细讲解二叉搜索树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值