【C++】二叉搜索树（BST）

chian-ocean2024-08-22 20:26

欢迎来到我的Blog，点击关注哦💕

前言：

在数据结构中学习过二叉树，链式二叉树，顺序二叉树，区别于二者的的一种特殊的二叉树是二叉搜索树

二叉搜索树介绍（BST）

二叉搜索树 （Binary Search Tree，BST）是一种特殊的二叉树

它具有以下性质：

  • 如果树非空，则左子树上所有节点的值都小于根节点的值，右子树上所有节点的值都大于根节点的值，且左右子树各自也是二叉搜索树。
  • 二叉搜索树的特点是能够快速执行查找、插入和删除操作，其时间复杂度通常为对数级别.

如下，是一个简易的二叉搜索树
1 3 4 6 7 8 9 10 12 13 14

二叉搜索树基本操作（BST）

二叉搜索树的存储结构（K模型）

  • 如果构成KV模型仅仅在加一个模板参数就好了
  • 二树经典的左右指针，和存储数据声明
cpp 复制代码 
template<class K>
    class BSTTree
    {
        public:
        BSTTree<K>* _left;
        BSTTree<K>* _right;
        K _key;


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

默认成员函数

拷贝构造

  • 采用递归的方式
cpp 复制代码 
Node* _Copy(Node* root)
{
    if (root == nullptr)
        return nullptr;

    Node* copynode = new Node(root->_key);

    copynode->_left = _Copy(root->_left);
    copynode->_right = _Copy(root->_right);

    return copynode;

}

赋值运算符号重载

  • 传值拷贝，直接进行交换
cpp 复制代码 
BST(const BST<K>& copy)
{
    _root = _copy(copy._root);
}

析构函数

  • 用~BST（）直接实现调用的递归
cpp 复制代码 
~BST()
{
    _destory(_root);
}

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

    _destory(root->_left);
    _destory(root->_right);
    delete root;
    root = nullptr;

}

BST查找

  • 二叉搜索树的查找操作从根节点开始，根据查找值与当前节点值的关系，选择向左子树或右子树递归查找。
  • 如果当前节点的值等于查找值，则找到该节点；如果小于查找值，则向右子树查找；如果大于查找值，则向左子树查找。如
  • 果查找过程中到达叶节点仍未找到对应值，则表明该值不存在于树中

迭代

cpp 复制代码 
bool Find(const K& key)
{
	if (_root == nullptr)
		return false;

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

递归

  • 由于在类的内部，类外参数不能传this指针，采用类内传递的形式，进而实现递归
cpp 复制代码 
bool Find(const K& key)
{
    return _Find(_root ,key);
}

bool _Find(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;
    }
}

BST插入

  • 插入操作首先检查树是否为空，如果为空，则新建一个包含待插入值的节点作为根节点。
  • 如果树不为空，则根据二叉搜索树的性质，从根节点开始向下遍历，直至找到一个空的子节点位置，将新节点插入到该位置。
  • 新节点总是作为叶节点插入，以保持树的二叉搜索树属性.

迭代

  • 开始判断树是否为空树
  • 建立parent节点记录父亲节点
  • 进行遍历，查找叶子节点插入
  • 保存父亲的节点作用在进行，叶子节点插入的时候进行判断，新节点和叶子节点的大小关系
cpp 复制代码 
bool Insert(const K& key)
{
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}

	Node* parent = nullptr;
	Node* cur = _root;

	while (cur)
	{
		parent = cur;
		if (key < cur->_key)
		{
			cur = cur->_left;
		}
		else if (key > cur->_key)
		{
			cur = cur->_right;
		}
		else
		{
			return false;
		}
	}

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

递归

  • 值得注意的点是传参数的时候是指针的引用。
  • 好处就是不用进行新节点与父亲节点的判断。
cpp 复制代码 
bool Insert(const K& key)
{
    return _Insert(_root,key);
}

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

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

BST删除

  • 删除操作较为复杂，因为需要考虑被删除节点可能有零个、一个或两个子节点的情况。
  • 删除操作通常涉及到找到被删除节点的适当继任者（在有两个子节点的情况下，通常是其右子树中的最小节点或左子树中的最大节点），并用继任者的值替换被删除节点的值，然后删除被替换的节点

迭代

三种情况：

  • 要删除的结点无孩子结点 （叶子节点）
  • 要删除的结点只有左孩子结点
  • 要删除的结点只有右孩子结点
  • 要删除的结点有左、右孩子结点
cpp 复制代码 
bool Erase(const K& key)
{
    Node* cur = _root;
    Node* parent = _root;

    while (cur)
    {
        if (key < cur->_key)
        {
            parent = cur;
            cur = cur->_left;
        }
        else if (key > cur->_key)
        {
            parent = cur;
            cur = cur->_right;
        }//找到键值
        else
        {	
            //左子树为空
            if (cur->_left == nullptr)
            {
                //祖先节点为键值
                if (cur == _root)
                {
                    cur = cur->_right;
                }
                else
                {
                    if (parent->_right == cur)
                    {
                        parent->_right = cur->_right;
                    }
                    else
                    {
                        parent->_left = cur->_right;
                    }
                }

            }//右子树为空
            else if (cur->_right == nullptr)
            {
                //祖先节点为键值
                if (cur == _root)
                {
                    _root = cur->_left;
                }
                else
                {
                    if (parent->_right == cur)
                    {
                        parent->_right = cur->_left;
                    }
                    else
                    {
                        parent->_left = cur->_left;
                    }
                }
            }
            else//左右子树均存在，查找右子树最大节点
            {
                Node* leftMax = cur->_left;
                while (leftMax->_right)
                {
                    parent = leftMax;
                    leftMax = leftMax->_right;
                }

                swap(leftMax->_key, cur->_key);
                //易错点，找到节点并不知道
                if (parent->_left == leftMax)
                {
                    parent->_left = leftMax->_left;
                }
                else
                {
                    parent->_right = leftMax->_left;
                }
                cur = leftMax;

            }
            delete cur;
            return true;

        }
    }
    return false;

}

迭代

  • 这里面也是指针的引用
cpp 复制代码 
bool Erase(const K& key)
{
    return _Erase(_root, key);
}

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

    if (key < root->_key)
    {
        return _Erase(root->_left, key);
    }
    else if(key>root->_key)
    {
        return _Erase(root->_right, key);
    }
    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 _Erase(root->_left, key);
        }
        delete del;
        return true;
    }
}

BST遍历

  • 直接递归实现
cpp 复制代码 
void _InOrder(Node* root)
{
    if (root == nullptr)
        return;

    _InOrder(root->_left);
    cout << root->_key << " ";
    _InOrder(root->_right);
}

源码

迭代

cpp 复制代码 
#pragma once


namespace MyBST
{
	template<class K>
	class BSTTree
	{
	public:
		BSTTree<K>* _left;
		BSTTree<K>* _right;
		K _key;
		

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



	template<class K>
	class BST
	{
		typedef BSTTree<K> Node;
	public:
		BST()
			:_root(nullptr)
		{}

		BST(const BST& t)
		{
			return _Copy(_root);
		}

		BST& operator=(const BST& t)
		{
			swap(_root, t._root);
			return *this;
		}
		~BST()
		{
			_destory();
		}

		bool Insert(const K& key)
		{
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}

			Node* parent = nullptr;
			Node* cur = _root;

			while (cur)
			{
				parent = cur;
				if (key < cur->_key)
				{
					cur = cur->_left;
				}
				else if (key > cur->_key)
				{
					cur = cur->_right;
				}
				else
				{
					return false;
				}
			}

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

		bool Find(const K& key)
		{
			if (_root == nullptr)
				return false;

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

		bool Erase(const K& key)
		{
			Node* cur = _root;
			Node* parent = _root;

			while (cur)
			{
				if (key < cur->_key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (key > cur->_key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
				{					
					if (cur->_left == nullptr)
					{
						if (cur == _root)
						{
							cur = cur->_right;
						}
						else
						{
							if (parent->_right == cur)
							{
								parent->_right = cur->_right;
							}
							else
							{
								parent->_left = cur->_right;
							}
						}

					}
					else if (cur->_right == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_right == cur)
							{
								parent->_right = cur->_left;
							}
							else
							{
								parent->_left = cur->_left;
							}
						}
					}
					else
					{
						Node* leftMax = cur->_left;
						while (leftMax->_right)
						{
							parent = leftMax;
							leftMax = leftMax->_right;
						}

						swap(leftMax->_key, cur->_key);
						//易错点
						if (parent->_left == leftMax)
						{
							parent->_left = leftMax->_left;
						}
						else
						{
							parent->_right = leftMax->_left;
						}
						cur = leftMax;

					}
					delete cur;
					return true;

				}
			}
			return false;

		}

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

	private:


		void _destory(Node* root)
		{
			if(root == nullptr)
			{
				return;
			}

			_destory(root->_left);
			_destory(root->_right);
			delete root;
			root = nullptr;

		}

		Node* _Copy(Node* root)
		{
			Node* copynode = new Node(root->_key);

			copynode->_left = _Copy(root->_left);
			copynode->_right = _Copy(root->_right);

			return copynode;
		}

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

			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}
		


		Node* _root;


	};
}

递归

cpp 复制代码 
#pragma once
#include<iostream>

using namespace std;

namespace MyBSTR
{
	template<class K>
	class BSTTree
	{
	public:
		BSTTree<K>* _left;
		BSTTree<K>* _right;
		K _key;


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



	template<class K>
	class BST
	{
		typedef BSTTree<K> Node;
	public:
		BST()
			:_root(nullptr)
		{}

		BST(const BST<K>& copy)
		{
			_root = _copy(copy._root);
		}

		BST& operator=(BST t)
		{
			swap(_root, t.root);
			return *this;
		}
		~BST()
		{
			_destory(_root);
		}

		bool Insert(const K& key)
		{
			return _Insert(_root,key);
		}

		bool Find(const K& key)
		{
			return _Find(_root ,key);
		}

		bool Erase(const K& key)
		{
			return _Erase(_root, key);
		}


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

	private:

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

			_destory(root->_left);
			_destory(root->_right);
			delete root;
			root = nullptr;
        
		}


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

			Node* copynode = new Node(root->_key);

			copynode->_left = _Copy(root->_left);
			copynode->_right = _Copy(root->_right);

			return copynode;

		}

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

			if (key < root->_key)
			{
				return _Erase(root->_left, key);
			}
			else if(key>root->_key)
			{
				return _Erase(root->_right, key);
			}
			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 _Erase(root->_left, key);
				}
				delete del;
				return true;
			}
		}


		bool _Find(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 _Insert(Node*& root ,const K& key)
		{
			if (root == nullptr)
			{
				root = new Node(key);
				return true;
			}

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

			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}



		Node* _root;

	};
}
相关推荐
熬夜学编程的小王6 分钟前
【C++篇】深度解析 C++ List 容器：底层设计与实现揭秘
开发语言·数据结构·c++·stl·list
yigan_Eins7 分钟前
【数论】莫比乌斯函数及其反演
c++·经验分享·算法
GIS 数据栈8 分钟前
每日一书 《基于ArcGIS的Python编程秘笈》
开发语言·python·arcgis
Mr.1311 分钟前
什么是 C++ 中的初始化列表？它的作用是什么？初始化列表和在构造函数体内赋值有什么区别？
开发语言·c++
阿史大杯茶14 分钟前
AtCoder Beginner Contest 381（ABCDEF 题）视频讲解
数据结构·c++·算法
陌小呆^O^23 分钟前
Cmakelist.txt之win-c-udp-server
c语言·开发语言·udp
C++忠实粉丝23 分钟前
计算机网络socket编程(3)_UDP网络编程实现简单聊天室
linux·网络·c++·网络协议·计算机网络·udp
Gu Gu Study30 分钟前
枚举与lambda表达式，枚举实现单例模式为什么是安全的，lambda表达式与函数式接口的小九九~
java·开发语言
时光の尘44 分钟前
C语言菜鸟入门·关键字·float以及double的用法
运维·服务器·c语言·开发语言·stm32·单片机·c
我们的五年1 小时前
【Linux课程学习】：进程描述---PCB（Process Control Block）
linux·运维·c++
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作