搜索二叉树（二叉搜索树）的实现（递归与非递归）

已于 2023-11-18 15:21:43 修改
阅读量810 收藏 91
点赞数 96
文章标签： 数据结构 c++ 算法
于 2023-11-18 15:19:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74265792/article/details/134477690
版权

一、搜索二叉树的概念

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

若它的左子树不为空，则左子树上所有节点的值都小于根节点的值

若它的右子树不为空，则右子树上所有节点的值都大于根节点的值

它的左右子树也分别为搜索二叉树。 

二、搜索二叉树的操作

1. 搜索二叉树的查找

a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。

b、最多查找高度次，走到到空，还没找到，这个值不存在。

template <class K>
bool BSTree<K>::Find(const K& key)
{
	node* cur = _root;
	while (cur)
	{
		if (key < cur->_key)//小就往左走
		{
			cur = cur->_left;
		}
		else if (key > cur->_key)//大就往右走
		{
			cur = cur->_right;
		}
		else//找到了
		{
			return true;
		}
	}
	return false;
}

2. 搜索二叉树的插入

a. 树为空，则直接新增节点，赋值给root指针

b. 树不空，按搜索二叉树性质查找插入位置，插入新节点

template <class K>
bool BSTree<K>::Insert(const K& key)
{
	//树为空，则直接新增节点，赋值给root指针
	if (_root == nullptr)
	{
		_root = new node(key);
		return true;
	}
	node* parent = nullptr;
	node* cur = _root;
	while (cur)//找到key该去的位置
	{
		parent = cur;
		if (cur->_key < key)//大就往右走
		{
			cur = cur->_right;
		}
		else if (cur->_key > key)//小就往左走
		{
			cur = cur->_left;
		}
		else//有相等的值了无法再插入了
		{
			return false;
		}
	}
	if (parent->_key < key)
	{
		parent->_right = new node(key);
	}
	else
	{
		parent->_left = new node(key);
	}

	return true;
}

3.搜索二叉树的删除

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

a. 要删除的结点无孩子结点

b. 要删除的结点只有左孩子结点

c. 要删除的结点只有右孩子结点

d. 要删除的结点有左、右孩子结点

看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程 如下：

情况a：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除

情况b：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除

情况c：在它的右子树中寻找中序下的第一个结点(关键码最小)，或者在它的左子树中寻找中序下的第一个结点(关键码最大)用它的值填补到被删除节点中，再来处理该结点的删除问题--替换法删除。

template <class K>
bool BSTree<K>::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//找到了就跳出循环
		{
			break;
		}
	}
	if (cur == nullptr)//cur走到空就意味着没找到
	{
		return false;
	}
	if (cur->_left == nullptr)//左为空 
	{
		if (cur == _root)
		{
			_root = cur->_right;
		}
		else if (cur == parent->_left)
		{
			parent->_left = cur->_right;
		}
		else if (cur == parent->_right)
		{
			parent->_right = cur->_right;
		}
		delete cur;
		return true;
	}
	else if (cur->_right == nullptr)//右为空
	{
		if (cur == _root)
		{
			_root = cur->_left;
		}
		else if (cur == parent->_left)
		{
			parent->_left = cur->_left;
		}
		else if (cur == parent->_right)
		{
			parent->_right = cur->_left;
		}
		delete cur;
		return true;
	}
	else//左右都不为空，去找它左树最大的节点替换它的值，再删除左树最大的节点
        //下面的图有做说明
	{
		node* parent = nullptr;
		node* leftMax = cur;
		while (leftMax->_right)//找到左树最大的节点
		{
			parent = leftMax;
			leftMax = leftMax->_right;
		}
		swap(cur->_key, leftMax->_key);//交换值
		if (parent->_left == leftMax)
		{
			parent->_left = leftMax->_left;
		}
		else
		{
			parent->_right = leftMax->_left;
		}
		delete leftMax;
		return true;
	}
	return false;
}

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

#pragma once

#include <iostream>
using namespace std;


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

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

template <class K>
class BSTree
{
private:
	BSTreeNode<K>* _root;
	typedef BSTreeNode<K> node;
public:
	BSTree()
		:_root(nullptr)
	{

	}
	~BSTree()
	{
		Destroy(_root);
	}
	//增删查
	bool Insert(const K& key);
	bool Find(const K& key);
	bool Erase(const K& key);
	//中序遍历
	void InOrder();
	void _InOrder(node* root);
	//增删查的递归实现
	bool InsertR(const K& key);
	bool _InsertR(const K& key, node*& root);
	//为了对节点进行修改，这里的插入和删除的节点必须用引用传，这里是一个细节 
	bool EraseR(const K& key);
	bool _EraseR(const K& key, node*& root);
	bool FindR(const K& key);
	bool _FindR(const K& key, node* root);

	void Destroy(node* root);
};


template <class K>
bool BSTree<K>::Insert(const K& key)
{
	//树为空，则直接新增节点，赋值给root指针
	if (_root == nullptr)
	{
		_root = new node(key);
		return true;
	}
	node* parent = nullptr;
	node* cur = _root;
	while (cur)//找到key该去的位置
	{
		parent = cur;
		if (cur->_key < key)//大就往右走
		{
			cur = cur->_right;
		}
		else if (cur->_key > key)//小就往左走
		{
			cur = cur->_left;
		}
		else//有相等的值了无法再插入了
		{
			return false;
		}
	}
	if (parent->_key < key)
	{
		parent->_right = new node(key);
	}
	else
	{
		parent->_left = new node(key);
	}

	return true;
}

template <class K>
bool BSTree<K>::Find(const K& key)
{
	node* cur = _root;
	while (cur)
	{
		if (key < cur->_key)//小就往左走
		{
			cur = cur->_left;
		}
		else if (key > cur->_key)//大就往右走
		{
			cur = cur->_right;
		}
		else//找到了
		{
			return true;
		}
	}
	return false;
}

template <class K>
bool BSTree<K>::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//找到了就跳出循环
		{
			break;
		}
	}
	if (cur == nullptr)//cur走到空就意味着没找到
	{
		return false;
	}
	if (cur->_left == nullptr)//左为空 
	{
		if (cur == _root)
		{
			_root = cur->_right;
		}
		else if (cur == parent->_left)
		{
			parent->_left = cur->_right;
		}
		else if (cur == parent->_right)
		{
			parent->_right = cur->_right;
		}
		delete cur;
		return true;
	}
	else if (cur->_right == nullptr)//右为空
	{
		if (cur == _root)
		{
			_root = cur->_left;
		}
		else if (cur == parent->_left)
		{
			parent->_left = cur->_left;
		}
		else if (cur == parent->_right)
		{
			parent->_right = cur->_left;
		}
		delete cur;
		return true;
	}
	else//左右都不为空，去找它左树最大的节点替换它的值，再删除左树最大的节点
	{
		node* parent = nullptr;
		node* leftMax = cur;
		while (leftMax->_right)//找到左树最大的节点
		{
			parent = leftMax;
			leftMax = leftMax->_right;
		}
		swap(cur->_key, leftMax->_key);//交换值
		if (parent->_left == leftMax)
		{
			parent->_left = leftMax->_left;
		}
		else
		{
			parent->_right = leftMax->_left;
		}
		delete leftMax;
		return true;
	}
	return false;
}

template <class K>
void BSTree<K>::_InOrder(node* root)
{
	if (root == nullptr)
		return;
	_InOrder(root->_left);
	cout << root->_key << " ";
	_InOrder(root->_right);
}

template <class K>
void BSTree<K>::InOrder()
{
	_InOrder(_root);
	cout << endl;
}


template <class K>
bool BSTree<K>::EraseR(const K& key)
{
	return _EraseR(key, _root);
}


template <class K>
bool BSTree<K>::_EraseR(const K& key, node*& root)
{
	if (root == nullptr)
		return false;
	if (root->_key < key)
	{
		_EraseR(key, root->_right);
	}
	else if (root->_key > key)
	{
		_EraseR(key, root->_left);
	}
	else//找到要删除的节点了
	{
		//准备开始删除
		node* del = root;
		if (root->_left == nullptr)
		{
			root = root->_right;
		}
		else if (root->_right == nullptr)
		{
			root = root->_left;
		}
		else
		{
			node* leftMax = root->_left;
			while (leftMax->_right)
			{
				leftMax = leftMax->_right;
			}
			swap(root->_key, leftMax->_key);
			return _EraseR(key, root->_left);//交换完后去要删除节点的左子树删除最大的节点
		}
		delete del;
	}
	return true;
}

template <class K>
bool BSTree<K>::FindR(const K& key)
{
	return _FindR(key, _root);
}

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

template <class K>
bool BSTree<K>::InsertR(const K& key)
{
	return _InsertR(key, _root);
}
template <class K>
bool BSTree<K>::_InsertR(const K& key, node*& root)
{
	if (root == nullptr)
	{
		root = new node(key);
		return true;
	}
	if (root->_key < key)
	{
		return _InsertR(key, root->_right);
	}
	else if (root->_key > key)
	{
		return _InsertR(key, root->_left);
	}
	else
	{
		return false;
	}
}

template <class K>
void BSTree<K>::Destroy(node* root)
{
	if (root == nullptr)
		return;
	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
}
//test.c

#include "BinarySearchTree.h"

int main()
{
	BSTree<int> bs;

	int arr[] = { 1,3,6,4,7,8,10,14,13 };
	for (auto e : arr)
	{
		bs.Insert(e);
	}
	bs.InOrder();

	bs.EraseR(1);
	bs.InOrder();

	bs.Insert(20);
	bs.InsertR(9);
	bs.InOrder();

	bool ret = bs.FindR(20);
	cout << ret << endl;


	return 0;
}

北飞的山羊
关注
  • 96
    点赞
  • 踩
  • 91
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 91
    评论
搜索二叉树递归操作
Hanani_Jia的博客
05-08 1580
 之前给大家介绍了搜索二叉树的非递归算法，今天给大家介绍一些搜索二叉树的递归算法的操作。  这里主要介绍的是插入，查找和删除。其实插入和之前的二叉树的操作是一样的，不过依然是需要判断你要查入的元素应当插入的位置。int BSTreeInsertR(BSTreeNode** tree, DataType x) { if (*tree == NULL) { *tree = BuyBSTreeN...
二叉搜索树的实现（递归方式）
weixin_73567058的博客
10-26 225
本文介绍了使用递归的方式实现BST的插入和删除操作，并提供了完整代码和测试案例。递归虽然简洁，但需要注意递归边界条件、参数传递方式等问题。在实际应用中，也可以使用迭代的方式实现BST的基本操作。
【二叉树进阶】搜索二叉树（递归+非递归两种版本详解）
m0_70980326的博客
07-30 1180
搜索二叉树详解：递归+非递归两种版本实现，画图讲解+完整代码
【数据结构】二叉搜索树的实现
学了就忘是正常现象
01-23 2092
递归删除：找到节点后，同样需要分三种情况讨论。 1、被删除节点左树为空； 2、被删除节点左树不为空但右树为空； 3、被删除节点左右子树均不为空。
二叉排序树（Binary Sort Tree）的查找递归算法
热门推荐
zhangvalue的博客
08-03 1万+
二叉排序树的查找是从根结点开始，沿着某一个分支逐层开始往下比较的过程。 若二叉排序树非空，将给定值与根结点的关键字比较，若相等则查找成功。 若不等，则当根结点的关键字大于给定关键字值时，在根结点的左子树中查找，否则在根结点右子树中查找。 递归调用查找函数，直到返回为找到的结点，或者为空结束。 BSTNode *BST_Search(BiTree T,ElemType key) //...
二叉树的递归套路——搜索二叉树
Harrison的学习博客
12-15 709
给定一棵二叉树的头节点head,返回这颗二叉树是不是搜索二叉树 搜索二叉树定义：左树所有结点比头结点小，右树所有结点比头结点大，每颗子树都如此。 根据二叉树的递归套路，直接得出每颗子树需要返回的信息就是： 整颗子树是否是搜索二叉树 整颗子树的最大值 整颗子树的最小值 比较简单，如果有不了解可以看看这篇文章——二叉树的递归套路——最大二叉搜索子树 接下来直接看代码叭： package com.harrison.class08; import java.util.ArrayList; public cl
二叉树-基于C++实现的二叉搜索树.zip
最新发布
04-26
为了实现插入、查找和删除的递归辅助函数，我们需要考虑每一步如何调整树的结构以保持二叉搜索树的特性。在删除操作中，我们可能需要找到一个替代节点来替换被删除的节点，以保持树的平衡。 在实际应用中，二叉搜索...
二叉树的二叉搜索表示.rar_二叉搜索树_二叉树的二叉搜索
09-22
在"二叉树的二叉搜索表示"的压缩包文件中，很可能包含了实现这些操作的C语言代码示例，供学习者理解和实践二叉搜索树的原理和应用。通过阅读和运行这些代码，可以深入理解二叉搜索树的工作机制，并进一步提升数据...
Python实现二叉搜索树BST的方法示例
01-20
二叉排序树（BST）又称二叉查找树、二叉搜索树 二叉排序树(Binary Sort Tree)又称二叉查找树。它或者是一棵空树；或者是具有下列性质的二叉树： 1.若左子树不空，则左子树上所有结点的值均小于根结点的值； 2.若...
数据结构 二叉树的递归与非递归
09-15
总结来说，二叉树的递归与非递归遍历是数据结构中重要的操作。递归遍历简单直观，适用于小规模问题；非递归遍历则适用于处理大规模数据，避免了递归带来的栈空间限制。理解这两种方法并能灵活运用，对于理解和实现...
C++ 二叉搜索树(BST)的实现方法
08-30
C++ 二叉搜索树(BST)是一种特殊的二叉树，它具有以下特征： 1. 二叉搜索树的每个节点都包含一个键值（key）和一个值（value）。 2. 对于任意一个节点，左子树中的键值都小于该节点的键值，而右子树中的键值都大于该...
二叉排序树的查找递归算法实现
qq_53439474的博客
11-19 4022
//二叉排序树 //可以用来排序 #include<stdio.h> #include<stdlib.h> //定义树节点 struct Binode { int data; Binode* lchild; Binode* rchild; }; //插入函数构建 void BSTinsert(Binode* &root, int key)//指针引用可修改指针的值，否则智能修改指针所指的值 { if (root == NULL) { root = (Binode
二叉搜索树的操作及其实现
yanxiang3306
10-19 4152
具体逻辑为：当树空的时候直接new一个结点即可，不空的情况下，当我们要插入一个元素的时候我们需要知道它的前一个元素，这样我们才能实现插入操作，插入的位置都是为空的，所以我们要查找到它适合的位置即可。它的查找方式是这样的：如果我们要查找6这个数字，那么我们从根节点开始，遇到根节点的val是5,6>5,所以我们要往右搜寻，遇到7的时候，6
二叉搜索树的实现
qq_62905847的博客
11-08 449
java详细实现二叉搜索树
用递归实现二叉搜索树
sunlifeall的博客
11-09 1117
用递归实现二叉搜索树
搜索二叉树的查找，插入，删除递归实现
HiMark
07-18 4617
搜索二叉树的概念 搜索二叉树满足下面两个要求： （1）它是一棵二叉树 （2）该二叉树中，任意一棵树的根节点值大于它左子树中的所有结点的值，小于右子树中的所有结点的值 因此对于搜索二叉树的中序遍历来说，它是按由小到大依次递增的顺序排列的。 1. 搜索二叉树的表示 3 //定义搜索二叉树的节点结构/孩子表示法 4 typedef char SearchTre...
数据结构之搜索二叉树递归&非递归
微风
10-18 2787
每天都进步一点你会发现这个世界真的不一样
用递归方式实现二叉树查找算法
zdl_01的博客
12-14 3494
实现二叉树查找算法
二叉搜索树的递归插入，python代码
04-27
下面是Python中实现二叉搜索树的递归插入代码： ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right class Solution: def ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

北飞的山羊

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

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

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

打赏作者

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

抵扣说明：

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

余额充值