搜索二叉树

已于 2024-03-02 11:17:12 修改
阅读量1k 收藏 29
点赞数 33
文章标签： 数据结构 c++ 二叉搜索树
于 2024-03-02 11:14:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67131528/article/details/136410442
版权

1.搜索二叉树的概念

搜索二叉树也称二叉排序树和二叉查找树，它具有以下性质：

若它的左子树不为空，则左子树上所有节点的值都小于根节点的值；
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 ；
它的左右子树也分别为二叉搜索树。
如上图所示就是一棵二叉搜索树，很显然，它是一棵特殊的二叉树。
我们不难发现，当二叉搜索树用中序遍历的时候，它是从小到大依次排序的，例如，我们中序遍历上图这棵树的结果是：1，3，4，6，7，8，10，13，14。所以说，这个结构的效率还是很高的，况且，遍历一遍自动排序，也是很方便的。

2.搜索二叉树的实现

搜索二叉树无非也是一棵二叉树，所以它只有一些特殊的功能和普通二叉树不一样，我们实现主要它的增、删、查，因为搜索二叉树左节点要比这个节点小，右节点的值要比它大，所以是不能插入已经存在的值的结点，插入的值也是不能修改的。下面我们开始实现。

2.1插入

要插入结点，我们首先需要构建一个结点Node的结构体，里面存放左节点，右节点和要插入的key值，

template<class K>
struct BSTreeNode
{
	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{

	}
	typedef BSTreeNode<K> node;
	node* _left;
	node* _right;
	K _key;

};
下面我们开始实现BSTree类主体。 
template<class K>
class BinarySearchTree
{
	typedef BSTreeNode<K> node;
public:
private:
	node* _root = nullptr;
};

开始插入结点：

要插入这个值，我们首先要去找这个值应该插入的位置在哪里，如果这个值比根节点的值大，就应该去根节点的右子树找，如果小就去左子树找，如果要插入的值，与当前根节点值相等，那就证明已经存在当前的值，那不能插入，需要返回false。

bool Insert(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 false;//要插入值已经存在，返回false。
	}
    
  }
//....cur为空，要插入的值不存在，可以插入
}

代码运行到省略号这里，代表可以插入值，但是我们需要首先判断根节点_root是不是空结点，如果是空结点，我们访问空结点的左右子树是野指针的

bool Insert(const K& key)
{
	if (_root == nullptr)//判断根为空的情况
	{
		_root = new node(key);
		return true;
	}
	node* cur = _root;
	while (cur)
	{
		if (cur->_key < key)
		{
			cur = cur->_right;//去右子树找
		}
		else if (cur->_key > key)
		{
			cur = cur->_left;//去左子树找，
		}
		else
		{
			return false;//要插入值已经存在，返回false。
		}

	}
	//....cur为空，要插入的值不存在，可以插入
}

这个时候，我们就可以直接在省略号的位置，直接new一个值为key的结点。

cur = new node(key);
return true;

大家想一下，这样就结束了吗？很显然没有，因为这个cur是一个局部变量，我们只是new出了一个结点赋给了cur,但是并没有把它链接在这棵树上，所以，我们在找要插入的位置的时候，需要一个父节点，每次cur变成新的结点的之前，cur都需要先赋给parent。再者，我们最后查好的时候，需要判断cur到底插入在parent结点的左边还是右边即：

bool Insert(const K& key)
{
	if (_root == nullptr)
	{
		_root = new node(key);
		return true;
	}
	node* cur = _root;
	node* parent = nullptr;
	while (cur)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}

	}
	cur = new node(key);
	if (parent->_key > key)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}
	return true;
}

这才是一个完整的插入，我们写一个中序遍历，插入几个结点，验证一下结果。

2.2中序遍历

void _Inorder(node* root)
{
	if (root == nullptr)
	{
		return;
	}
	_Inorder(root->_left);
	cout << root->_key << " ";
	_Inorder(root->_right);
}
void Inorder()
{
	_Inorder(_root);
	cout << endl;
}

因为中序需要递归，而函数的参数默认有this->_root,所以我们不需要传参，但是递归需要传参，所以在这里我们封装一个_Inorder(Node* root)，真正的中序函数，直接调用就可以啦。

测试：

#include"BSTree.h"
void test1()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	BinarySearchTree<int> b;
	for (auto e : a)
	{
		b.Insert(e);
	}
	b.Inorder();
}
int main()
{
	test1();
	return 0;
}

结果与预期相符

2.3查找

查找其实我们插入一开始就写的过，就是看key比根节点大还是小，大就去根的右边，小就去左边，相等就是找到了。

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

2.4删除

删除算是搜索二叉树里面难度相对比较高的，很多细节我们需要考虑。

首先，我们考虑，删除的结点如果没有孩子，也就是删除叶子结点，还是比较容易的，直接把这个结点删除就可以了；如果删除的结点有一个孩子，也就是左右子树有一个为空，其实相对也还能实现，我们只需让自己的父节点指向自己自己的孩子就可以了。就比如如果要删除当前节点，但是当前节点的左子树为空，那就可以直接让父节点指向自己的右子树，然后删除当前节点就可以了；但是还有一种情况，如要删除的结点左右子树都不为空怎么办？父节点最多只能指向一个，现在我有两个结点，该怎么删？这里介绍一种方法——替换法。即要删除的结点左右孩子都不为空，我们不能破坏搜索树的规则，那就去找到左子树的最大值，或者我们找到右子树的最小值，找到其中一个，然后与要删除的值替换，然后再删除我们要删除的值。因为我们去找左子树的最大值，首先它要比要删除结点cur的其它左子树都要大，比cur右子树的所有结点都要小，况且它身为cur左子树的最大值，它断然是没有右子树的，那把这个结点的值赋给cur，我们都把左最大的值给要删除的cur了,然后删除左最大这个结点不就Ok了嘛；同理我们也可以找cur右子树最小值，它会比所有cue的右子树结点都小，比所有cur左子树结点都大，它身为cur右树最小值结点，肯定是没有左子树的。那这个左树最大结点，右树最小结点怎么找呢？右树最小结点，一定在右子树最左边，因为它的最小的，它一定是别人的左子树，所以它一直都在左边，直到它这里没有左子树了，它就是最小的。同理，左子树最大值也是左子树最右边的结点。

下面我们慢慢来实现，这里是以找右树最小结点为例

bool Erase(const K& key)
{
	node* cur = _root;
	node* parent = nullptr;
	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)//cur左边为空，把右孩子交给父节点
			{
				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)//cur右树为空
			{
				if (cur == _root)//判断右树为空，删除_root情况
				{
					_root = cur->_left;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}

				delete cur;
				return true;
			}
			else//替换法：处理要删除的结点左右孩子都不为空
			{
				node* RightParent = cur;
				node* Rightmin = cur->_right;
				while (Rightmin->_left)//去右树左边找右树最小结点
				{
					RightParent = Rightmin;
					Rightmin = Rightmin->_left;
				}
				cur->_key = Rightmin->_key;//右树最小结点的值赋给要删除的cur，删除右树最小结点
				if (RightParent->_left == Rightmin)
					RightParent->_left = Rightmin->_right;
				else
					RightParent->_right = Rightmin->_right;
				delete Rightmin;
				return true;
			}

		}

	}
	return false;
}

我们测试结果

void test1()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	BinarySearchTree<int> b;
	for (auto e : a)
	{
		b.Insert(e);
	}
	b.Inorder();
	b.Erase(8);//删除根节点8
	b.Inorder();
}
int main()
{
	test1();
	return 0;
}

再把所有结点都删一遍

void test1()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	BinarySearchTree<int> b;
	for (auto e : a)
	{
		b.Insert(e);
	}
	b.Inorder();
	b.Erase(8);//删除根节点8
	b.Inorder();

	cout << "********************" << endl;
	for (auto e : a)
	{
		b.Erase(e);
		b.Inorder();
	}
}

验证可以看到，我们的删除并没有问题。

这次分享就到这里，下面附上源码

3.源码

//面向对象面向君，不负代码不负卿
#include<iostream>
using namespace std;
template<class K>
struct BSTreeNode
{
	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{

	}
	typedef BSTreeNode<K> node;
	node* _left;
	node* _right;
	K _key;

};
template<class K>
class BinarySearchTree
{
	typedef BSTreeNode<K> node;
public:
	void _Inorder(node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Inorder(root->_left);
		cout << root->_key << " ";
		_Inorder(root->_right);
	}
	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 Insert(const K& key)
	{
		if (_root == nullptr)//判断根为空的情况
		{
			_root = new node(key);
			return true;
		}
		node* cur = _root;
		node* parent = nullptr;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;//去右子树找
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;//去左子树找，
			}
			else
			{
				return false;//要插入值已经存在，返回false。
			}

		}
		//....cur为空，要插入的值不存在，可以插入
		cur = new node(key);
		if (parent->_key > key)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		return true;
	}
	bool Erase(const K& key)
	{
		node* cur = _root;
		node* parent = nullptr;
		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)//cur左边为空，把右孩子交给父节点
				{
					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)//cur右树为空
				{
					if (cur == _root)//判断右树为空，删除_root情况
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}

					delete cur;
					return true;
				}
				else//替换法：处理要删除的结点左右孩子都不为空
				{
					node* RightParent = cur;
					node* Rightmin = cur->_right;
					while (Rightmin->_left)//去右树左边找右树最小结点
					{
						RightParent = Rightmin;
						Rightmin = Rightmin->_left;
					}
					cur->_key = Rightmin->_key;//右树最小结点的值赋给要删除的cur，删除右树最小结点
					if (RightParent->_left == Rightmin)
						RightParent->_left = Rightmin->_right;
					else
						RightParent->_right = Rightmin->_right;
					delete Rightmin;
					return true;
				}

			}

		}
		return false;
	}

private:
	node* _root = nullptr;
};

七街酒465
关注
  • 33
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 20
    评论
Leetcode 搜索二叉树中错误节点
一只老风铃
09-06 739
题目描述 一棵二叉树原本是搜索二叉树，但是其中有两个节点调换了位置，使得这棵二叉树不再是搜索二叉树，请按升序输出这两个错误节点的值。(每个节点的值各不相同) 思路： 搜索二叉树最重要性质为中序遍历为升序 那么交换的可能是 前后两个节点交换，那么中序遍历存在一组逆序对 中间隔开若开个节点交换，那么中序遍历存在两组逆序对 那么只要记录下第一组逆序对的第一个元素，以及最后一组逆序对的第二个元素，即为原先交换的两个数 关键实现 对于一组逆序对（first,second） ...
二叉树：搜索二叉树和完全二叉树
小菜鸟也想飞的博客
05-02 5893
二叉树：搜索二叉树和完全二叉树
【中等】调整搜索二叉树中两个错误的节点－Java：原问题
了解➔熟悉➔掌握➔精通
07-03 559
package live.every.day.ProgrammingDesign.CodingInterviewGuide.BinaryTree; import java.util.Stack; /** * 调整搜索二叉树中两个错误的节点 * * 【题目】 * 一棵二叉树原本是搜索二叉树，但是其中有两个节点调换了位置，使得这棵二叉树不再是搜索二叉树，请找到这两个错误节点并返回。 * 已知二叉树中所有节点的值都不一样，给定二叉树的头节点head，返回一个长度为２的二叉树节点类型的数组errs，e
二叉树的概念以及搜索二叉树【建议收藏】
x0919的博客
08-20 2293
hello, everyone. Long time no see. 本期文章，我们主要讲解一下二叉树的相关概念，顺便也把搜索二叉树（也叫二叉排序树）讲一下。我们直接进入正题吧！GitHub源码链接 文章目录一、二叉树的概念二、搜索二叉树 一、二叉树的概念 为什么要使用二叉树？ 为什么要用到树呢?因为它通常结合了另外两种数据结构的优点:一种是有序数组，另一种是链表。在树中查找数据项的速度和在有序数组中查找一样快，并且插入数据项和删除数据项的速度也和链表一样。下面，我们先来稍微思考一下这些话题，然后再深
平衡二叉树&搜索二叉树
薛定谔的Hello Kitty
06-22 416
设n(h)表示为高度为h的平衡二叉树的最小节点数，则 n(h) = n(h-1) + n(h-2) + 1，也就是高度为h-1的平衡树最少节点数+高度为h-2的最小节点数+1 。 这点类似于fibolacci数列 ，n(h) = F(n+2) - 1 下面是如何建立搜索二叉树： ...
验证搜索二叉树
2301_80926085的博客
05-12 1087
Leetcode--98.验证搜索二叉树。本文详细介绍两种解法。两千字讲解+图解。
判断一棵二叉树是否是搜索二叉树
niceYF的博客
03-13 1196
搜索二叉树的判定
【算法】【二叉树模块】判断一棵二叉树是否为搜索二叉树和完全二叉树
qq_39760347的博客
10-03 663
判断二叉树是搜索二叉树和完全二叉树的判断方法
左神算法：找到二叉树中符合搜索二叉树条件的最大拓扑结构（Java版）
热门推荐
寒泉
12-18 6万+
本题来自左神《程序员代码面试指南》“找到二叉树中符合搜索二叉树条件的最大拓扑结构”题目。 题目 牛客OJ：找到二叉树中符合搜索二叉树条件的最大拓扑结构 给定一棵二叉树的头节点head，已知所有节点的值都不一样，返回其中最大的且符合搜索二叉树条件的最大拓扑结构的大小。 例如，二叉树如图 3-19 所示。 其中最大的且符合搜索二叉树条件的拓扑结构如图3-20 所示。 这个拓扑结构节点数为8，所以返回8。 题解 方法一：二叉树的节点数为N，时间复杂度为O(N^2)的方法。 首先来看这样一个问题，以节点 h.
搜索二叉树c语言版本
08-13
c语言实现的搜索二叉树。实现了对树的增加数据，删除数据，中序遍历数据。
js实现搜索二叉树.rar
06-08
javascript实现二叉树 中序遍历 后序遍历 前序遍历 二叉树创建 中间节点的删除 叶子节点的删除
数据结构搜索二叉树.rar
07-16
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树...
【数据结构】——搜索二叉树的插入，查找和删除（递归&非递归）
02-26
本代码是在windows平台下vs2008上编译通过，包含搜索二叉树的插入，查找和删除算法（采用递归和非递归两种方法）。包含全部在平台下的文件，解压可以直接运行。
搜索二叉树的各种操作 创建 查找 遍历 插入 删除
01-20
搜索二叉树的各种操作 创建 查找 遍历 插入 删除 在GCC下编译通过。
树--搜索二叉树
Beau Wang
05-29 786
线索二叉树充分利用了指针空间，同时又便于寻找结点的前驱结点和后继结点。线索二叉树适用于经常需要遍历寻找结点前驱或者后继结点的二叉树。
Redis 中 Set 数据结构详解
最新发布
llt2997632602的博客
05-29 650
Redis 中 Set 的常用命令，编码，场景整理。
数据结构——图论详细笔记
2301_79376014的博客
05-27 524
一 图论基本概念二 图的存储。
C++：round函数用法
Solititude的博客
05-28 341
C++：round函数用法
C++实现搜索二叉树
05-30
可以使用结构体和指针来实现搜索二叉树，具体实现方法如下： ```c++ #include using namespace std; // 定义二叉树节点结构体 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x)...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值