二叉搜索树的增删查改

最新推荐文章于 2024-04-04 00:08:02 发布
最新推荐文章于 2024-04-04 00:08:02 发布
阅读量429 收藏
点赞数 1
分类专栏： 数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qingqiulengya/article/details/51703242
版权
本文深入探讨了二叉搜索树的基础知识，重点讲解了如何在二叉搜索树中进行插入、删除、查找和修改操作。通过理解这些操作，可以更好地掌握数据结构中的平衡搜索树原理。
摘要由CSDN通过智能技术生成

二叉搜索树注重增删查改，现在针对key/value形式进行研究。

现在对其进行实现，分别有插入，查找，删除，分别对这几个功能用递归和非递归实现。           其中删除操作比较特别，分为 3种,分别是删除叶子节点，删除左为空或右为空的节点， 第三种是删除左右子树都不为空的节点。最后一种删除最麻烦，它分为三个步骤，分别是找出右树的最左节点，然后和要删除的节点进行key/value的互换，然后再删除它最左节点。

代码实现： 
template<class K,class V>
struct BinarySearchTreeNode //key/value形式
{
                BinarySearchTreeNode( const K & key, const V& value)
                :_key( key)
                , _value( value)
                , _left( NULL)
                , _right( NULL)
                {}
                 K _key;
                 V _value;
                 BinarySearchTreeNode<K , V>* _left;
                 BinarySearchTreeNode<K , V>* _right;
};

template<class K, class V>
class BinarySearchTree
{
                 typedef BinarySearchTreeNode <K, V> Node;
public:
                BinarySearchTree()
                                :_root( NULL)
                {}

                 bool Insert(const K& key,const V& value)//插入(非递归)
                {
                                 if (_root == NULL )//开始无节点
                                {
                                                _root = new Node (key, value);
                                                 return true ;
                                }

                                 Node* parent = NULL ;
                                 Node* cur = _root;
                                 while (cur)
                                {
                                                 if (key < cur->_key)
                                                {
                                                                parent = cur;
                                                                cur = cur->_left;
                                                }
                                                 else if (key>cur->_key)
                                                {
                                                                parent = cur;
                                                                cur = cur->_right;
                                                }
                                                 else
                                                                 return false ;
                                }
                                 if (parent->_key > key )
                                                parent->_left = new Node (key, value);
                                 else
                                                parent->_right = new Node (key, value);
                                 return true ;            
                }

                 bool InsertR(const K& key,const V& value)//插入（递归）
                {
                                 return _InsertR(_root, key , value);
                }

                 Node* Find(const K& key)//查找（非递归）
                {
                                 if (_root == NULL )
                                                 return NULL ;
                                
                                 Node* cur = _root;
                                 while (cur)
                                {
                                                 if (cur->_key == key )
                                                                 return cur;
                                                 else if (key < cur->_key)
                                                                cur = cur->_left;
                                                 else
                                                                cur = cur->_right;
                                }
                                 return NULL ;
                }

                 Node* FindR(const V& key)//插入（递归）
                {
                                 return _FindR(_root, key );
                }

                 bool Remove(const K& key)//删除节点（非递归）
                {
                                 if (_root == NULL )
                                                 return false ;
                                
                                 Node* cur = _root;
                                 Node* parent=NULL ;
                                 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 == NULL &&cur->_right == NULL)//叶子节点
                                                                {
                                                                                 Node* del = cur;
                                                                                 delete del;
                                                                                del = NULL;
                                                                                 return true ;
                                                                }

                                                                 else if (cur->_left == NULL||cur->_right == NULL)//右树或左树为空
                                                                {
                                                                                 Node* del = cur;
                                                                                 if (parent->_right==cur)
                                                                                {
                                                                                                 if (cur->_right == NULL )
                                                                                                {
                                                                                                                parent->_right = cur->_left;
                                                                                                                 delete del;
                                                                                                                del = NULL;
                                                                                                                 return true ;
                                                                                                }
                                                                                                 else if (cur->_left == NULL)
                                                                                                {
                                                                                                                parent->_right = cur->_right;
                                                                                                                 delete del;
                                                                                                                del = NULL;
                                                                                                                 return true ;
                                                                                                }
                                                                                }
                                                                                 else if (parent->_left==cur)
                                                                                {
                                                                                                 Node* del = cur;
                                                                                                 if (cur->_left == NULL )
                                                                                                {
                                                                                                                parent->_left = cur->_right;
                                                                                                                 delete del;
                                                                                                                del = NULL;
                                                                                                                 return true ;
                                                                                                }
                                                                                                 else if (cur->_right == NULL)
                                                                                                {
                                                                                                                parent->_left = cur->_left;
                                                                                                                 delete del;
                                                                                                                del = NULL;
                                                                                                                 return true ;
                                                                                                }
                                                                                }
                                                                }
                                                                 if (cur->_left != NULL &&cur->_right != NULL)//左树和右树都不为空
                                                                {
                                                                                 Node* parent = cur;
                                                                                 Node* FirstLeft = cur->_right;
                                                                                 while (FirstLeft->_left)//找右树的最左节点
                                                                                {
                                                                                                parent = FirstLeft;
                                                                                                FirstLeft = FirstLeft->_left;
                                                                                }

                                                                                swap(cur->_key, FirstLeft->_key);//交换
                                                                                swap(cur->_value, FirstLeft->_value);
                                                                                 Node* del = FirstLeft;
                                                                                 if (parent->_left==FirstLeft)
                                                                                                parent->_left = FirstLeft->_right;
                                                                                 else
                                                                                                parent->_right = FirstLeft->_right;
                                                                                 delete del;
                                                                                del = NULL;
                                                                                 return true ;
                                                                }                                              
                                                }
                                }
                                 return false ;//未找到要删除的节点
                }

                 bool RemoveR(const K& key)//删除（递归）
                {
                                 return _RemoveR(_root,key );
                }

                 void InOrder()//中序遍历
                {
                                _InOrder(_root);
                                cout << endl;
                }

protected:
                 bool _RemoveR(Node *& root,const  K& key )//删除会修改_root,用引用
                {
                                 if (root == NULL)
                                                 return false ;
                
                                 if (key < root->_key)
                                                _RemoveR( root->_left, key );
                                 else if (key> root->_key)
                                                _RemoveR( root->_right, key );
                                 else//相等
                                {
                                                 if (root ->_right == NULL)//右子树为空
                                                {
                                                                 root = root ->_left;
                                                                 delete root ;
                                                                 root = NULL ;
                                                                 return true ;
                                                }
                                                 else if (root->_left == NULL)//左子树为空
                                                {
                                                                 root = root ->_right;
                                                                 delete root ;
                                                                 root = NULL ;
                                                                 return true ;
                                                }
                                                 else//左右子树都不为空
                                                {
                                                                 Node* FirstLeft = root ->_right;
                                                                 Node* parent = root ;
                                                                 while (FirstLeft->_left)//找最左节点
                                                                {
                                                                                parent = FirstLeft;
                                                                                FirstLeft = FirstLeft->_left;
                                                                }

                                                                swap( root->_key, FirstLeft->_key);//交换
                                                                swap( root->_value, FirstLeft->_value);
                                                                _RemoveR( root->_right, key );//继续递归右树的最左节点
                                                }
                                }
                }

                 bool _InsertR(Node *& root,const K& key,const V& value)//添加会修改_root,所以用引用
                {
                                 if (root == NULL)
                                {
                                                 root = new Node(key, value);
                                                 return true ;
                                }
                                 if (key < root->_key)
                                                _InsertR( root->_left, key , value);
                                 else if (key> root->_key)
                                                _InsertR( root->_right, key , value);
                                 else//相等
                                                 return false ;

                }

                 Node* _FindR(Node * root, const K& key)//查找
                {
                                 if (root == NULL)
                                                 return NULL ;
                                 if (root ->_key == key)
                                                 return root ;
                                 else if (key < root->_key)
                                                _FindR( root->_left, key );
                                 else
                                                _FindR( root->_right, key );
                }

                 void _InOrder(Node * root)//中序递归写法
                {
                                 if (root == NULL)
                                                 return;
                                
                                                _InOrder( root->_left);
                                                cout << root->_value << " " ;
                                                _InOrder( root->_right);
                }
private:
                 Node* _root;
};
/*******************************************************************************************************************************************/ 
void test11()
{
                 BinarySearchTree<int , int> s1; //实现key/value形式的搜索树
                 int arr[10] = { 5, 3,1, 7 };
                 for (int i = 0; i < 4; i++)
                {
                                s1.Insert(arr[i], i);
                }

                 //s1.InOrder();

                 //cout << s1.Find(4)->_value << endl;
                 //cout << s1.Find(5)->_value << endl;
                 //cout << s1.Find(7)->_value << endl;

                 //s1.Remove(7);
                 //s1.Remove(3);
                
                
                 //s1.Remove(5);
                 //s1.InOrder();

                cout << s1.FindR(1)->_value << endl;
}

void test2()
{
                 BinarySearchTree<int , int> s1; //实现key/value形式的搜索树
                 int arr[10] = { 5, 3, 1, 7 };
                 for (int i = 0; i < 4; i++)
                {
                                s1.InsertR(arr[i], i);
                }

                 //s1.InOrder();

                s1.RemoveR(1);
                s1.InOrder();
                s1.RemoveR(5);
                s1.InOrder();
}


二叉搜索树存在缺陷，就是左右分布十分不均匀，这样造成二叉搜索树的退化
例如：

需要解决这个问题就是平衡搜索树。

qingqiulengya
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉搜索树的思想，以及增删查改的实现
qq_46209845的博客
09-07 683
目录搜索树的概念查找操作插入操作删除操作改的操作 搜索树的概念 二叉搜索树又被称为排序树，它或者是一颗空树，或者是一棵具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 下图就是一棵二叉搜索树，可以对应上面性质加深理解： 查找操作 实现思想： 实现代码： // O(树的高度) public boolean find(int key) { Node curren
Python实现二叉搜索树增删改查
TaloyerG的博客
08-10 555
二叉搜索树，可以让你像搜索引擎一样快速地存储和检索数据。本文你将介绍二叉搜索树的基本概念和性质，以及如何用Python代码来实现它的基本操作和应用。
【数据结构】二叉搜索树——二叉搜索树的概念和介绍、二叉搜索树的简单实现、二叉搜索树的增删查改
Crocodile1006的博客
09-06 2410
数据结构、二叉搜索树、二叉搜索树的概念和介绍、二叉搜索树的简单实现、二叉搜索树的插入、二叉搜索树的查找、二叉搜索树的遍历、二叉搜索树的删除、完整代码和测试
二叉排序树增删改查
wdquan19851029的专栏
06-27 314
二叉排序树(BST--Binary Sort Tree)，要求任何一个非叶子节点，左子节点的值小于当前节点的值，右子节点的值大于当前节点的值。如果有相等的值，可以将其放在左子节点或者右子节点。 优点是既能快速查找，又能快速增删 其它数据结构的劣势： 数组（未排序）：查找速度慢（相对于二叉排序树） 数组（已排序）：可以使用二分查找、查找速度快，缺点：为了保证数组有序，在插入新数据，找到插入位置时，后面的数据需要整体迁移，速度慢。 链表：查找很慢，增删很快 package com.bruce....
数据结构：二叉搜索树的增删查改
BudingCode的博客
03-29 1376
二叉查找树的增删查改
C++实现二叉搜索树的增删查改（非递归玩法）
最新发布
2301_79811170的博客
04-04 1284
二叉搜索树（Binary Search Tree）又称二叉排序树（Binary Sort Tree），是一种特殊类型的二叉树，它所有的根节点大于左子树的节点，小于右子树的节点，对二叉搜索树进行中序遍历，即可得到有序的数列。二叉搜索树的时间复杂度由树的高度决定，其搜索、插入和删除的时间复杂度均为 O(log n)，其中 n 是节点数。在最坏的情况下，仍然会有 O(n)的时间复杂度。二叉搜索树的时间复杂度由树的高度决定，其。查找非常简单按照流程找就行了。
数据结构之二叉搜索树的增删查改（图解，代码6000多字总结）
冷萃美式的博客
08-16 694
文章目录一：概念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 258
#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 =
【C++】模拟实现二叉搜索树的增删查改功能
邓富民的博客
09-08 660
本文章讲述了二叉搜索树的增删查改功能，其中有一些细节需要特别注意。
数据结构与算法之顺序表的增删查改
07-03
相反，如果频繁进行插入和删除，链表或者更高级的数据结构如平衡二叉搜索树可能会更合适。 总的来说，理解并熟练掌握数据结构与算法中的顺序表及其操作对于任何程序员来说都是基础且重要的。通过深入学习和实践，你...
数据结构C语言的二叉排序树
11-09
二叉排序树广泛应用于数据库索引、文件系统、编译器符号表、内存管理等场景，尤其在动态数据集合的增删查改操作中，由于其高效的特性，能显著提升程序性能。 通过这个压缩包文件，你可以学习到如何用C语言实现二叉...
二叉排序树的建立，删除，查找，动态
05-06
二叉排序树（Binary Sort Tree，BST），也称为二叉搜索树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键值，且满足以下性质：对于任意节点，其左子树中的所有节点的键值都小于该节点的键值，而右子树中的...
动态树的写法，动态树详细介绍
03-06
- AVL树：一种自平衡的二叉搜索树，通过左右旋操作保持每个节点的左右子树高度差不超过1。 - 红黑树：也是一种自平衡二叉查找树，通过红色和黑色节点的规则保持大致平衡，允许的最大不平衡因子是2。 - Splay树：每次...
两种查找算法，二叉树查找，折半查找
09-15
总结一下，折半查找适合有序数据，而二叉树查找适用于更动态的数据环境，特别是在数据频繁增删查改时。了解并熟练掌握这两种查找算法对于理解和优化程序的性能至关重要。通过严蔚敏教授的算法书籍学习，你可以更深入...
冒泡排序的优化及最好最差情况
热门推荐
qingqiulengya的博客
06-05 1万+
最开始学习的时候并没有对其进行深入的思考，现在对其进行总结，冒泡排序的思想也就不需要赘述。 最开我们会将数列进行n-1趟排序，每趟又进行一个循环的冒泡，如果是升序，我们就会将相邻的两个元素进行比较，将大的元素一直向后面“沉”,直到所有循环结束，这是数列也就被我们排序完成。 代码如如下： void BubbleSort(int* parr,int size)//冒泡排序（升序） {
利用哈夫曼树进行文件压缩
qingqiulengya的博客
07-25 6569
项目描述： 项目简介：利用哈夫曼编码的方式对文件进行压缩，并且对压缩文件可以解压 开发环境：windows vs2013 项目概述：                  1.压缩          a.读取文件，将每个字符，该字符出现的次数和权值构成哈夫曼树  b.哈夫曼树是利用小堆构成，字符出现次数少的节点指针存在堆顶，出现次数多的在堆底  c.每次取堆顶的两个数，再将两个数
BitMap的原理及使用
qingqiulengya的博客
06-08 5952
位图：位图的原理就是用一个bit来标识一个数字是否存在，采用一个bit来存储一个数据，所以这样可以大大的节省空间。 例如一个int型有32bit，那么就可以用这32个bit来存储0~31这些整型数据，所以可以将1~31这些数据仅用1个bit来存储，这样节省了空间。 例如要存储3，7，4，8 主要把握的是映射关系 代码实现： class BitMap {
直接选择排序和它的优化
qingqiulengya的博客
06-02 1475
直接选择排序是一种比较直观的排序，它是从一个无序的额数组中选择一个最小或最大的并将这个最大的放在数组的开始或末尾，现在进行代码的实现： /****/ if (parr [j] /********************/ 现在这个选择排序还有很大的优化空间，上述的方法的时间复杂度为O（n^2）。现在的优化方式是同时选出他的最大的和最小的。 代码实现： void Se
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->right = nullptr; } }; ``` 2. 二叉搜索树类的实现： ```c++ class BST { public: Node* root; BST() { root = nullptr; } // 插入操作 void insert(int val) { root = insertNode(root, val); } // 删除操作 void remove(int val) { root = removeNode(root, val); } // 查找操作 bool search(int val) { return searchNode(root, val); } // 修改操作 void modify(int oldVal, int newVal) { remove(oldVal); insert(newVal); } private: // 插入结点 Node* insertNode(Node* node, int val) { if (node == nullptr) { return new Node(val); } if (val < node->val) { node->left = insertNode(node->left, val); } else if (val > node->val) { node->right = insertNode(node->right, val); } return node; } // 删除结点 Node* removeNode(Node* node, int val) { if (node == nullptr) { return nullptr; } if (val < node->val) { node->left = removeNode(node->left, val); } else if (val > node->val) { node->right = removeNode(node->right, val); } else { if (node->left == nullptr && node->right == nullptr) { delete node; node = nullptr; } else if (node->left == nullptr) { Node* temp = node; node = node->right; delete temp; } else if (node->right == nullptr) { Node* temp = node; node = node->left; delete temp; } else { Node* temp = findMin(node->right); node->val = temp->val; node->right = removeNode(node->right, temp->val); } } return node; } // 查找结点 bool searchNode(Node* node, int val) { if (node == nullptr) { return false; } if (val == node->val) { return true; } else if (val < node->val) { return searchNode(node->left, val); } else { return searchNode(node->right, val); } } // 查找最小值 Node* findMin(Node* node) { while (node->left != nullptr) { node = node->left; } return node; } }; ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值