二叉搜索树的增删查改

最新推荐文章于 2024-06-01 13:53:57 发布
最新推荐文章于 2024-06-01 13:53:57 发布
阅读量61 收藏
点赞数
分类专栏： C++ 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fahaxiki_lyt/article/details/133681636
版权

二叉搜索树

概念

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

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

如下图即为一颗二叉搜索树：image-20230930145449751

**值得注意的是：**二叉搜索树通过中序遍历得到的序列是升序的。如上得到序列：1 3 4 6 7 8 10 13 14

性能分析

二叉树有多高，搜索的最大次数就是多少image-20230926105600627

普通的二叉搜索树搜索的最坏时间复杂度是O（N），如上面的右图；最好时间复杂度是O(logN)，如上面的左图

二叉搜索树的实现

框架设计

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

    BSTreeNode* _left;
    BSTreeNode* _right;
    K _key;
};

template<class K>
class BSTree
{
    typedef BSTreeNode<K> Node;   
public:
    …………
private:
	Node* _root;
};

中序遍历

给出中序遍历，方便对二叉搜索树进行打印

public:		
	//中序遍历
    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }
private:
    void _InOrder(Node* root)
    {
        if (root == nullptr)
        {
            return;
        }

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

之前的中序遍历是只有下面的void _InOrder(Node* root)这一个函数的。但由于_root是私有成员，我们无法在外部获取_root并将其作为参数传入_InOrder中。因此采取了上述再套一层函数的方法。

这种方法在后面实现二叉搜索树递归实现时会频繁使用。

其实也可以用GetRoot函数在外部获取_root，但没有上述好。上述既不暴露根结点，也能实现中序遍历

二叉搜索树的非递归实现

插入
bool Insert(const K& key)
{
    //如果树为空，直接新增结点赋值给_root
    if (_root == nullptr)
    {
        _root = new Node(key);
        return true;
    }

    Node* cur = _root;
    Node* parent = nullptr;
    while (cur)
    {
        //插入的值比根值大则插入右边
        if (key > cur->_key)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (key < cur->_key)//插入的值比根值小则插入左边
        {
            parent = cur;
            cur = cur->_left;
        }
        else//和根值一样大，说明不需要再插入
        {
            return false;
        }
    }

    cur = new Node(key);
    //虽然cur已经到达正确的位置，但我是不知道是在parent左边还是右边的，所以还需要判断一下
    if (parent->_key < key)
    {
        parent->_right = cur;
    }
    else
    {
        parent->_left = cur;
    }
    return true;
}
查找
bool Find(const K& key)
{
    Node* cur = _root;
    while (cur)
    {
        //比根值大
        if (key > cur->_key)
        {
            cur = cur->_right;
        }
        else if (key < cur->_key)//比根值小
        {
            cur = cur->_left;
        }
        else//和根值一样大，说明不需要再插入
        {
            cout << "找到了" << endl;
            return true;
        }
    }

    return false;
}
删除

删除相较于插入和查找复杂很多，也是经常考察的地方

待删除结点有四种情况：

  1. 要删除的结点无孩子结点
  2. 要删除的结点只有左孩子结点
  3. 要删除的结点只有右孩子结点
  4. 要删除的结点左右孩子结点都有

但实际上第1种情况可以归为第2或3种情况中的任意一种（如果情况2的代码先写，那么情况1就走情况2的代码）

因此真正的删除过程如下：

  • 情况2：删除该结点且使被删除结点的父节点指向被删除结点的左孩子结点
  • 情况3：删除该结点且使被删除结点的父节点指向被删除结点的右孩子结点
  • 情况4：找出被删除结点的左子树的最大结点或者右子树的最小结点，将被删除结点与该结点交换值。至此情况变成了1或2或3中的一种，再处理该结点的删除问题

针对情况2和情况3，为直接删除

针对情况4，为间接删除，又称替换法

情况1和情况2和情况3
//被删除结点的左边为空
if (cur->_left == nullptr)
{
    if (cur == _root)
    {
        _root = 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;
        }

    }
}

image-20230930154058769

假设要删除4，对应情况1。由于上述代码在删除部分，先写的“被删除结点左边为空”的情况，因此被删除结点左右都为空也是走的这种情况。

image-20230930154225368

假设要删除6，对应情况2。但这里还有一种特殊情况，即被删除结点是根结点：image-20230930154406947

由于被删除的结点是根节点，而根节点没有父结点

情况4
else//左右都不为空，替换法
{
    //找替换结点，左边最大或右边最小
    Node* parent = cur;
    Node* maxleft = cur->_left;
    while (maxleft->_right)
    {
        parent = maxleft;
        maxleft = maxleft->_left;
    }
    //这里找出左边最大并交换
    swap(cur->_key, maxleft->_key);

    if (parent->_left == maxleft)
    {
        parent->_left = maxleft->_left;
    }
    else
    {
        parent->_right = maxleft->_left;
    }

    cur = maxleft;
}

假设我找的替换结点是左子树的最大结点。在替换后，被删除结点的情况要么是情况1要么是情况2

这里存在一种特殊情况如下：image-20230930155540638

假设我要删除根节点8。那么 Node* parent = cur;这句就很关键，且下面的if和else的判断也很有必要

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

    while (cur)
    {
        //比根值大
        if (key > cur->_key)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (key < cur->_key)//比根值小
        {
            parent = cur;
            cur = cur->_left;
        }
        else//和根值一样大，开始删除
        {
            //被删除结点的左边为空
            if (cur->_left == nullptr)
            {
                if (cur == _root)
                {
                    _root = 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* parent = cur;
                Node* maxleft = cur->_left;
                while (maxleft->_right)
                {
                    parent = maxleft;
                    maxleft = maxleft->_left;
                }
                //这里找出左边最大并交换
                swap(cur->_key, maxleft->_key);

                if (parent->_left == maxleft)
                {
                    parent->_left = maxleft->_left;
                }
                else
                {
                    parent->_right = maxleft->_left;
                }

                cur = maxleft;
            }

            delete cur;
            return true;
        }
    }

    return false;
}

二叉搜索树的递归实现

由于递归实现需要传根节点，因此一般都会套一层函数，如中序遍历

插入
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 (root->_key > key)//比根值小就插入到左子树
        {
            _InsertR(root->_left, key);
        }
        else if (root->_key < key)//比根值大就插入到右子树
        {
            _InsertR(root->_right, key);
        }
        else//和根值一样就没必要插入了
        {
            return false;
        }
    }

image-20230929105045158

这里的关键点就是函数_InsertR的参数中的那个引用。那这个引用有什么好处呢？

  • 假设是空树，那么_root就是nullptr，root就是_root的别名。然后就会root=new Node(key)，直接给根赋值

  • 假设插入的是5，如上图。一直递归到了结点4，此时传入结点4的右指针nullptr，root就是结点4右指针的别名，那么直接将结点5赋给结点4的右指针，就自动完成了链接

查找
public:
	bool FindR(const K& key)
    {
        return _FindR(_root, key);
    }
private:
    bool _FindR(Node* root, const K& key)
    {
        if (root == nullptr)
            return false;

        if (root->_key > key)//比根值小就到左子树找
        {
            _FindR(root->_left, key);
        }
        else if (root->_key < key)//比根值大就到右子树找
        {
            _FindR(root->_right, key);
        }
        else//找到了
        {
            return true;
        }
    }
删除
public:
    bool EraseR(const K& key)
    {
        return _EraseR(_root, key);
    }
private:
    bool _EraseR(Node*& root, const K& key)
    {
        if (root == nullptr)
            return false;

        if (root->_key > key)//比根值小就到左子树中去删除
        {
            _EraseR(root->_left, key);
        }
        else if (root->_key < key)//比根值大就到右子树中去删除
        {
            _EraseR(root->_right, key);
        }
        else//实施删除
        {
            //将被删除的root保存下来
            Node* del = root;

            if (root->_left == nullptr)//root的左孩子为空
            {
                root = root->_right;
            }
            else if (root->_right == nullptr)//root的右孩子为空
            {
                root = root->_left;
            }
            else//root的左右孩子都不为空
            {
                //找出最大左孩子
                Node* leftmax = root->_left;
                while (leftmax->_right)
                {
                    leftmax = leftmax->_right;
                }

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

                return _EraseR(root->_left, key);//这里我们已经知道需要被删除的数据是在左子树中的，所以直接递归即可。虽然会重复再找一次需要删除的数据，但代价不大
            }

            delete del;
            return true;
        }
    }

也如插入一样利用引用简化

在非递归中不用引用是因为引用不能改变指向。递归里的引用是在不同的栈帧，所以每次都是新的引用

二叉搜索树的其余函数

析构函数

后序删除

public:
    ~BSTree()
    {
        Destroy(_root);
    }

private:
    void Destroy(Node*& root)
    {
        //后序销毁
        if (root == nullptr)
            return;

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

加引用是方便将root置空

拷贝构造

前序拷贝。遇到8就拷贝8，遇到3就拷贝3

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

private:
	Node* Copy(Node* root)
    {
        //前序拷贝
        if (root == nullptr)
        {
            return nullptr;
        }

        Node* copyroot = new Node(root->_key);
        copyroot->_left = Copy(root->_left);
        copyroot->_right = Copy(root->_right);
        return copyroot;
    }
赋值运算符重载

现代写法：

public:
    BSTree<K>& operat(BSTree<K> t)
    {
        swap(_root, t._root);
        return *this;
    }

二叉搜索树的应用

二叉搜索树的应用有两大场景：

  • key的搜索模型：快速判断在不在的场景，如门禁系统
  • key-value的搜索模型：通过一个值找另外一个值，如找快递

之前讲的都是key的搜索模型。下面来看看key/value的搜索模型：

其实与key的搜索模型相比没什么，就是在结点中多存一个value。最主要的还是key

比如说字典，假设英文是key，那么中文就是value。可以通过英文得到对应的中文

再比如说，统计水果出现的次数

之所以上述用二叉搜索树实现，一个是因为字符串可以比较大小，第二个是因为二叉搜索树的搜索效率高

在key模型的基础下，修改后代码如下：（没写的函数说明和key模型是一样的）

namespace key_value
{
	template<class K,class V>
	struct BSTreeNode
	{
		BSTreeNode(const K& key,const V& value)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
			,_value(value)
		{}

		BSTreeNode* _left;
		BSTreeNode* _right;
		K _key;
		V _value;
	};

	template<class K,class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;

	public:
		BSTree()
			:_root(nullptr)
		{}


		//中序遍历
		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);
		}

		//删除的递归版本
		bool EraseR(const K& key)
		{
			return _EraseR(_root, key);
		}

	private:
		void Destroy(Node*& root)
		{
			//后序销毁
			if (root == nullptr)
				return;

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

		Node* Copy(Node* root)
		{
			//前序拷贝
			if (root == nullptr)
			{
				return nullptr;
			}

			Node* copyroot = new Node(root->_key);
			copyroot->_left = Copy(root->_left);
			copyroot->_right = Copy(root->_right);
			return copyroot;
		}

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

			if (root->_key > key)//比根值小就到左子树找
			{
				_FindR(root->_left, key);
			}
			else if (root->_key < key)//比根值大就到右子树找
			{
				_FindR(root->_right, key);
			}
			else//找到了
			{
				return root;
			}
		}

		bool _InsertR(Node*& root, const K& key,const V& value)
		{
			if (root == nullptr)
			{
				root = new Node(key,value);//正是因为参数的引用，使得这里可以直接完成链接操作
				return true;
			}

			if (root->_key > key)//比根值小就插入到左子树
			{
				_InsertR(root->_left, key,value);
			}
			else if (root->_key < key)//比根值大就插入到右子树
			{
				_InsertR(root->_right, key,value);
			}
			else//和根值一样就没必要插入了
			{
				return false;
			}
		}

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

			if (root->_key > key)//比根值小就到左子树中去删除
			{
				_EraseR(root->_left, key);
			}
			else if (root->_key < key)//比根值大就到右子树中去删除
			{
				_EraseR(root->_right, key);
			}
			else//实施删除
			{
				//将被删除的root保存下来
				Node* del = root;

				if (root->_left == nullptr)//root的左孩子为空
				{
					root = root->_right;
				}
				else if (root->_right == nullptr)//root的右孩子为空
				{
					root = root->_left;
				}
				else//root的左右孩子都不为空
				{
					//找出最大左孩子
					Node* leftmax = root->_left;
					while (leftmax->_right)
					{
						leftmax = leftmax->_right;
					}

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

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

				delete del;
				return true;
			}
		}

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

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

	private:
		Node* _root;
	};
}

微笑的高圆圆圆圆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉排序树增删改查
02-19
ios编程：实现二叉排序树增删改查。 开发环境：windows下codeblocks。
二叉搜索树增删改查完整实现(C++)
zorchp
01-19 1341
-
二叉树结构c++代码实现（只涉及增加删除查找）
f593256的博客
06-13 86
结合教材和视频课整理的，删除部分可以简化很多，主要还是看自己的逻辑思路。
C++ 不知树系列之二叉排序树（递归和非递归遍历、删除、插入……）
y6123236的专栏
11-04 1376
本文讲解了什么是二叉排序树，并深入地探讨在二叉排序树如何进行数据的插入、遍历、删除……
【数据结构】二叉搜索树——二叉搜索树的概念和介绍、二叉搜索树的简单实现、二叉搜索树的增删查改
Crocodile1006的博客
09-06 2112
数据结构、二叉搜索树、二叉搜索树的概念和介绍、二叉搜索树的简单实现、二叉搜索树的插入、二叉搜索树的查找、二叉搜索树的遍历、二叉搜索树的删除、完整代码和测试
数据结构：二叉搜索树的增删查改
BudingCode的博客
03-29 1364
二叉查找树的增删查改
C++实现二叉搜索树的增删查改（非递归玩法）
2301_79811170的博客
04-04 1247
二叉搜索树（Binary Search Tree）又称二叉排序树（Binary Sort Tree），是一种特殊类型的二叉树，它所有的根节点大于左子树的节点，小于右子树的节点，对二叉搜索树进行中序遍历，即可得到有序的数列。二叉搜索树的时间复杂度由树的高度决定，其搜索、插入和删除的时间复杂度均为 O(log n)，其中 n 是节点数。在最坏的情况下，仍然会有 O(n)的时间复杂度。二叉搜索树的时间复杂度由树的高度决定，其。查找非常简单按照流程找就行了。
数据结构之二叉搜索树的增删查改（图解，代码6000多字总结）
冷萃美式的博客
08-16 659
文章目录一：概念1.用处2.定义3. 性质4.遍历伪代码5.基本操作5.1 查找5.2 最小关键字5.3 最大关键字5.4 插入5.5 删除 一：概念 1.用处  二叉搜索树既可以作为一个字典又可以作为一个优先队列 2.定义  顾名思义，二叉搜索树是一颗具有一定性质的二叉树。 可以使用一个链表来表示，其中的每一个节点都是一个对象，除了key和卫星数据之外，么一个节点还包含属性left,right，parent。如果对应的节点不存在的时候，则相应属性的值为nil。 根节点是整棵树中唯一一个父指针为nil的节点
二叉搜索树基本操作(增删查改)
Eighteen
10-26 250
#include<iostream> using namespace std; typedef struct Tree { int data; struct Tree* l; struct Tree* r; }*BTree; void insert(BTree root, int data) { BTree p, s, tmp=root; p = root; while (p) { tmp = p; if (data < p->data) { p =
python 版本的树的增删查改
08-14
用python 写成的树结构的增删查改，便于以后调用
C#二叉搜索树插入算法实例分析
01-21
本文实例讲述了C#二叉搜索树插入算法。分享给大家供大家参考。具体实现方法如下： public class BinaryTreeNode { public BinaryTreeNode Left { get; set; } public BinaryTreeNode Right { get; set; } public...
二叉搜索树实例练习
09-05
一棵二叉查找树是按二叉树结构来组织的。这样的树可以用链表结构表示，其中每一个结点都是一个对象
Python实现二叉搜索树BST的方法示例
09-18
主要介绍了Python实现二叉搜索树BST的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
浙江大学数据结构MOOC-课后习题-第十讲-排序4 统计工龄
chan1ee的博客
05-28 347
题目汇总。
【数据结构】链表与顺序表的比较
最新发布
SWsunlight的博客
06-01 879
顺序表和链表比较
短期总结（数据结构学完有感）
chan1ee的博客
05-29 308
从刚开始废寝忘食地学习，到中途自己过度关注题目的AC而忽略自己对知识的掌握，再到后面的沉下心去好好钻研，这段时间的收获确实很大，不光是知识层面，还有自己对学习的认识和态度。我的OS学习计划参考了其他博主的心得，打算先看哈工大的网课，并且完成课后Lab，最后参考《操作系统真想还原》动手实现一个小型操作系统。这18天我几乎没有休息过，每天早上7:30起床，晚上9点多才回宿舍，太久没有这么高强度学习过，确实让我的身心都有点疲劳了。接下来的打算就是，和女朋友一起玩几天，然后就开始投身于操作系统的学习。
C-数据结构-树转存广义表-广义表转成树-实例
aqiangdeba的博客
05-28 319
【代码】C-数据结构-树转存广义表-广义表转成树-实例。
c++二叉查找树增删查改
11-11
以下是C++实现二叉搜索树的增删查改的示例代码： 1. 结点类的实现： ```c++ class Node { public: int val; Node* left; Node* right; Node(int val) { this->val = val; this->left = nullptr; this->...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值