c++的学习之路：24、 二叉搜索树概念

已于 2024-04-17 22:34:48 修改
阅读量885 收藏 14
点赞数 23
分类专栏： c++ 文章标签： 学习 算法 c++ 开发语言
于 2024-04-17 20:02:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64257568/article/details/137885440
版权

摘要

本章主要是讲一下二叉搜索树的实现

目录

摘要

 一、二叉搜索树概念

二、 二叉搜索树操作

1、二叉搜索树的查找

2、二叉搜索树的插入

3、二叉搜索树的删除

三、二叉搜索树的实现

1、插入

2、中序遍历

3、删除

4、查找

四、二叉搜索树的递归实现

1、插入

2、删除

3、查找

五、代码

test.c

BSTree.h

六、思维导图

 一、二叉搜索树概念

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

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

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

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

如下图所示的图片就是一个二叉搜索树。

二、 二叉搜索树操作

这个就是不在附图了，就是上面那个图，他的数值就是int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};这个数组所示的数值。

1、二叉搜索树的查找

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

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

2、二叉搜索树的插入

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

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

如下图所示

3、二叉搜索树的删除

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

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

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

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

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

根据上述情况有下面几种情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除，情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除，情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题--替换法删除，也就是找个保姆

三、二叉搜索树的实现

1、插入

想要插入首先要构建节点，如下方块种代码，就是申请一个节点，这个就不用多说了，第二个快的代码就是申请插入，就是如果没有也就是空的时候就申请一个节点，然后判断需要插入的数值，如果大于跟节点就给给左，如果小于就是右边，然后在循环中进行下去，直到找到合适的位置进行插入，如果有相同的就返回false，测试插入成功在中序遍历进行打印查看。

template<class T>
struct BSTreeNode
{
    BSTreeNode<T>* _left;
    BSTreeNode<T>* _right;
    T _key;
    BSTreeNode(const T& key)
        :_left(nullptr)
        , _right(nullptr)
        , _key(key)
    {}
};

typedef BSTreeNode<K> Node;
    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->_left = cur;
        }
        else
        {
            parent->_right = cur;
        }
        return true;
    } 

2、中序遍历

在下方块种的代码就是测试中序的，这个就没啥说的就是递归打印，但是有一点要注意，root节点是私密的在外面访问不到，没法使用，这里需要借用一个没有参数的函数进行打印，如下方代码所示，测试结果如图。

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

3、删除

这个就是优点麻烦了，他就是和上面所写操作中的三种情况，根据这三种情况进行写，首先就是寻找相等的，这个就没啥说的了，找到后就是判断左边为空和右边为空的两种情况，找到相等的时候，然后进行判断是否需要链接，这里是不管需不需要都进行链接，因为一种是后续有节点进行连接，一种是没有直接连接为空，刚好解决这两中情况，然后就是左右都不为空的时候，这个需要找个托孤的，就有点像我学Linux的时候遇到的孤儿进程被1号进程托孤一样，这里就是左边最大节点和右边最小节点，然后进行换一下，在进行删除，这里代码如下，测试如图。

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 (parent->_left == cur)//如果cur在父节点的左边，就把cur右边的值托孤给父,如果是空，刚好是空节点给父
                        {
                            parent->_left = cur->_right;
                        }
                        else//如果cur在父节点的右边，就把cur左边的值托孤给父
                        {
                            parent->_right = cur->_right;
                        }

                    }
                    delete cur;
                }
                //右为空
                else if (cur->_right == nullptr)
                {
                    if (cur == _root)//如果是根节点,右边都是空，只有左边有值
                    {
                        _root = cur->_left;
                    }
                    else//不是根节点
                    {
                        if (parent->_left = cur)//如果cur在父节点的左边，就把cur右边的值托孤给父,如果是空，刚好是空节点给父
                        {
                            parent->_left = cur->_left;
                        }
                        else//如果cur在父节点的右边，就把cur左边的值托孤给父
                        {
                            parent->_right = cur->_left;
                        }

                    }
                    delete cur;
                }
                else
                {
                    // 找右树最小节点替代，也可以是左树最大节点替代
                    Node* pminRight = cur;
                    Node* minRight = cur->_right;
                    while (minRight->_left)
                    {
                        pminRight = minRight;
                        minRight = minRight->_left;
                    }

                    cur->_key = minRight->_key;

                    if (pminRight->_left == minRight)
                    {
                        pminRight->_left = minRight->_right;
                    }
                    else
                    {
                        pminRight->_right = minRight->_right;
                    }
                    delete minRight;
                }
                return true;
            }
        }
        return false;
    }

4、查找

这个就是直接进行查找就好了，比根节点大就去右边找，小就是左边找，如下代码所示，测试如图。

bool Find(const K& key)
    {
        Node* cur = _root;
        while (cur)
        {
            if (cur->_key > key)
            {
                cur->_left;
            }
            else if(cur->_key<key)
            {
                cur->_right;
            }
            else
            {
                cout << cur->_key << endl;
                return true;
            }
        }
        return false;
    }

四、二叉搜索树的递归实现

1、插入

这里世界利用递归去插入，如果为空就创建一个节点，没有的判断是否比根小，小的话就去左边递归，大的就去右边递归，因为这个需要root节点所以和上面所说的中序一样进行利用函数进行使用直接传递key值就可以了，如下代码，这里的测试放在最后了，和上面测试一样的。

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

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

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

2、删除

这个删除和上面差不多也是三种情况，这里也是利用递归去查找，就是在最后一种需要注意下，这里是利用左边最大的节点交换，然后进行递归查找，但是需要注意这里需要利用引用传值进行删除。

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

    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->_right == nullptr)
            {
                root = root->_left;
            }
            else if (root->_left == nullptr)
            {
                root = root->_right;
            }
            else
            {
                Node* maxleft = root->_left;
                while (maxleft->_right)
                {
                    maxleft = maxleft->_right;
                }

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

                return _EraseR(root->_left, key);
            }

            delete del;

            return true;
        }
    }

3、查找

这个递归的查找就是判断，如果没有找到节点为空的时候就返回false，找到了就返回true，然后大于的话就去左边，小于就去右边，如下方代码所示，测试如图。

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

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

        if (root->_key == key)
            return true;

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

五、代码

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <vector>
using namespace std;
#include "BSTree.h"

//void Test()
//{
//	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
//	BSTree<int> t1;
//	
//	for (auto e : a)
//	{
//		t1.Insert(e);
//	}
//	t1.Find(8);
//	t1.InOrder();
//	cout << endl;
//
//	for (auto e : a)
//	{
//		t1.Erase(e);
//		t1.InOrder();
//		cout << endl;
//	}
//
//	t1.InOrder();
//	cout << endl;
//}

void Test()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	BSTree<int> t1;
	
	for (auto e : a)
	{
		t1.InsertR(e);
	}
	cout<<t1.FindR(8)<<endl;
	t1.InOrder();
	cout << endl;

	for (auto e : a)
	{
		t1.EraseR(e);
		t1.InOrder();
		cout << endl;
	}

	t1.InOrder();
	cout << endl;
}

int main()
{
	Test();
	return 0;
}

BSTree.h

#pragma once

template<class T>
struct BSTreeNode
{
	BSTreeNode<T>* _left;
	BSTreeNode<T>* _right;
	T _key;
	BSTreeNode(const T& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};
template<class K>
class BSTree
{
public:
	typedef BSTreeNode<K> Node;
	BSTree() = default; // 制定强制生成默认构造

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

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

	~BSTree()
	{
		Destroy(_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->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		return true;
	}
	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				cur->_left;
			}
			else if(cur->_key<key)
			{
				cur->_right;
			}
			else
			{
				cout << cur->_key << endl;
				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 (parent->_left == cur)//如果cur在父节点的左边，就把cur右边的值托孤给父,如果是空，刚好是空节点给父
						{
							parent->_left = cur->_right;
						}
						else//如果cur在父节点的右边，就把cur左边的值托孤给父
						{
							parent->_right = cur->_right;
						}

					}
					delete cur;
				}
				//右为空
				else if (cur->_right == nullptr)
				{
					if (cur == _root)//如果是根节点,右边都是空，只有左边有值
					{
						_root = cur->_left;
					}
					else//不是根节点
					{
						if (parent->_left = cur)//如果cur在父节点的左边，就把cur右边的值托孤给父,如果是空，刚好是空节点给父
						{
							parent->_left = cur->_left;
						}
						else//如果cur在父节点的右边，就把cur左边的值托孤给父
						{
							parent->_right = cur->_left;
						}

					}
					delete cur;
				}
				else
				{
					// 找右树最小节点替代，也可以是左树最大节点替代
					Node* pminRight = cur;
					Node* minRight = cur->_right;
					while (minRight->_left)
					{
						pminRight = minRight;
						minRight = minRight->_left;
					}

					cur->_key = minRight->_key;

					if (pminRight->_left == minRight)
					{
						pminRight->_left = minRight->_right;
					}
					else
					{
						pminRight->_right = minRight->_right;
					}
					delete minRight;
				}
				return true;
			}
		}
		return false;
	}
	void InOrder()
	{
		_InOrder(_root);
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_key << ' ';
		_InOrder(root->_right);
	}

	void Destroy(Node*& root)
	{
		if (root == nullptr)
			return;

		Destroy(root->_left);
		Destroy(root->_right);

		delete root;
		root = nullptr;
	}

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

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

		if (root->_key == key)
			return true;

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

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

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

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

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

	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->_right == nullptr)
			{
				root = root->_left;
			}
			else if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else
			{
				Node* maxleft = root->_left;
				while (maxleft->_right)
				{
					maxleft = maxleft->_right;
				}

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

				return _EraseR(root->_left, key);
			}

			delete del;

			return true;
		}
	}
private:
	Node* _root = nullptr;
};

六、思维导图

懒懒学c
关注
  • 23
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
二叉搜索树（C#，C++）
10-11
在《算法导论》第三版的第12章中，作者详细介绍了二叉搜索树的概念、操作和实现。通过阅读此章，读者可以深入理解二叉搜索树的原理，并学会如何在实际编程中应用这些知识。实现过程中，需要关注代码的正确性和效率，...
最优二叉搜索树
06-26
最优二叉搜索树，也称为最优化二叉查找树或者动态二叉搜索树，是计算机科学中的一个重要概念，尤其在算法设计与分析领域占据一席之地。这种数据结构主要用于提高查询效率，在某些特定操作序列下，它能比普通二叉搜索...
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
C++实现二叉搜索树查找算法主要涉及以下几个核心概念： 1. **节点定义**：首先，我们需要定义一个二叉搜索树的节点结构。这个结构通常包括键值、指向左右子节点的指针以及可能的额外信息，如指向父节点的指针等。 ...
二叉排序树资源：可以实现排序功能，c++编写
05-29
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或二叉搜索树，是一种自平衡的二叉树数据结构，它在计算机科学中用于数据存储和检索。二叉排序树的主要特性是，每个节点的左子树只包含比当前节点值小的节点...
二叉排序树C++
01-21
二叉排序树（Binary Sort Tree，BST），也称为二叉搜索树或有序二叉树，是一种自平衡的二叉树数据结构。在二叉排序树中，对于任意一个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都...
AvaloniaUI的学习
最新发布
lishuangquan1987的博客
07-25 912
官方中文文档：https://docs.avaloniaui.net/zh-Hans/docs/welcome。
Python编程学习第一篇——Python零基础快速入门（六）（4）异常处理
urhero的专栏
07-25 355
我们已经了解了Python的基本数据类型、变量和基本的逻辑控制语句，基于这些基础知识可以编写一些小程序了，但是在写程序的时候我们会发现，有时候程序并不是按我们预期的方向执行，有的直接报错，有的没有报错，却并未得到我们预期的结果。在这个例子中，除数为0会引发ZeroDivisionError异常，我们将异常信息赋值给变量e，并输出"除数不能为0"和异常信息。在这个例子中，由于除数不为0，所以没有发生ZeroDivisionError异常，代码会执行else语句块，并输出结果2.0。
Spring Security学习笔记（二）Spring Security认证和鉴权
飞！！！的博客
07-24 777
用户认证的基础Filter，只有UsernamePasswordAuthenticationFilter这一个实现类。...//主要方法//先校验请求url与表单校验提交的url是否一致，不一致执行下一个Filter//一致的话就执行认证逻辑，一般默认的表单提交url是"/login"if (!} else {try {//实现类执行具体的认证逻辑return;//由子类实现具体的验证逻辑...
虚拟机学习
weixin_63374588的博客
07-25 309
虚拟机的优点：虚拟机使用教程：
前端学习1——自学习梳理
qq_63125992的博客
07-24 380
【代码】前端学习1——自学习梳理。
FastAPI（八十）实战开发《在线课程学习系统》接口开发-- 课程列表
mr~li的博客
07-25 361
源码见："
SAP PP学习笔记31 - 计划运行的步骤2 - Scheduling(日程计算)，BOM Explosion(BOM展开）
shi_ly的专栏
07-24 836
本章主要讲Scheduling(日程计算),其中包括 外部调达中的调度，生产订单中的调度，修改需求日期(其实就是在物料中增加安全时间和BOM中的提前期偏置量)。另外还讲了BOM展开的内容，详细讲了BOM选择的各种方法，除了按数量选BOM之外，还有其他比如 按日期，按生产版本等，而其中按日期又分为按订单开始日期，订单终了日期等，越趋复杂。
FastAPI（七十一）实战开发《在线课程学习系统》接口开发-- 查看留言
mr~li的博客
07-24 332
梳理后发现，之前在接口设计的时候，有些欠缺，查看留言，是查看单个的留言，查看留言后，对应的留言变成已读状态。那么我们这个都需要传递一个参数，这个参数应该是留言的id。之前FastAPI（七十）实战开发《在线课程学习系统》接口开发--留言功能开发分享了留言开发，这次我们分享查看留言。在之前设计返回状态码的时候，发现状态码有缺失，我们增加下缺失的。3.判断是否是当前用户的留言，或者接受的方是自己。梳理这里的逻辑，这个接口要依赖登录。5.如果已读且回复了，要带回复的内容。以上则是实现查看留言的接口逻辑。
【学习笔记】子集DP
Brute♂force
07-24 1039
有一类问题和子集有关。给你一个集合S，令T为S的超集，也就是S所有子集的集合，求T中所有元素的和。
(leetcode学习)236. 二叉树的最近公共祖先
m0_54888411的博客
07-24 716
中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（跟着左神的视频课，参考了左神的解题方法，不过时间上打败30%，记录一下，以后提升。给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。因为根据定义最近公共祖先节点可以为节点本身。的最近公共祖先是节点。的最近公共祖先是节点。
学习Servlet
secret010的博客
07-24 1000
Servlet是sun公司提供的一门用于开发动态web资源的技术，可以实现和客户端的交互，接收客户端和给客户端返回。
DP学习——外观模式
huibin.yun的博客
07-24 390
学而时习之，温故而知新。
后端开发工程师vue2初识的学习
音符犹如代码的博客
07-24 1107
快速认识vue
网络学习｜如何理解服务的端口号
weixin_44435110的博客
07-24 990
端口号（Port Number）是网络传输层协议（如TCP或UDP）用来识别特定服务或应用程序的数字标识符。每个IP地址可以有多个端口号，每个端口号代表不同的服务。例如，HTTP服务通常使用端口80，而HTTPS服务使用端口443。回答: 端口号是网络传输层协议用来识别特定服务或应用程序的数字标识符。端口号的存在允许同一台计算机同时运行多个网络服务，例如Web服务器和邮件服务器，区分这些服务需要不同的端口号。回答: 端口转发是将一个网络端口上的通信重定向到另一个端口的技术。
FreeModbus学习——读输入寄存器eMBFuncReadInputRegister
rerrick_rose的博客
07-24 618
也就是说经过eMBFuncReadInputRegister这个函数处理之后，打包好的帧已经放在了pucFrame，长度放在了usLen。调用回调函数eMBRegInputCB读取寄存器数据，eMBRegInputCB这个函数会把读到的数据继续存放在pucFrameCur 帧里。就是说这个指针pucFrameCur刚开始指向pucFrame这一帧数据的起始位置，然后打包一个数据，pucFrameCur＋一个。读寄存器数据，其实就是读数组嘛，寄存器是16位的，所以定义数组也是16位的SHORT型。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值