BST 二叉搜索树 BinarySearchTree C++实现(递归/非递归)
二叉搜索树
基本概念
二叉搜索树(BST,Binary Search Tree)
二叉搜索树又称二叉排序树,它或者是一棵空树,或者是具有以下性质的二叉树:
- 若它的左子树不为空,则左子树上所有节点的值都小于根节点的值
- 若它的右子树不为空,则右子树上所有节点的值都大于根节点的值
- 它的左右子树也分别为二叉搜索树
int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};
二叉搜索树/二叉查找树也称二叉排序树,因为二叉排序树的中序遍历结果是升序
常用结论
二叉搜索树的左子树一定小于根,右子树一定大于根,结合定义递归子树可以得到
左子树的最右节点是左子树的最大节点,右子树的最右节点是右子树的最大节点.
左子树的最左节点是左子树的最小节点,右子树的最左节点是右子树的最小节点.
二叉搜索树的最小节点是左子树的最左节点,最大节点是右子树的最右节点
用途
实际情况很少直接使用搜索二叉树,多是根据搜索二叉树的高效搜索特性,衍生出更为实用的高阶数据结构,例如平衡二叉搜索树(AVL树,红黑树)等...
- K模型:K模型即只有key作为关键码,结构中只需要存储Key即可,关键码即为需要搜索到的值。(在不在的问题)
比如:给一个单词word,判断该单词是否拼写正确,具体方式如下:
以词库中所有单词集合中的每个单词作为key,构建一棵二叉搜索树
在二叉搜索树中检索该单词是否存在,存在则拼写正确,不存在则拼写错误。
还有如:门禁系统,车库系统等...
- KV模型:每一个关键码key,都有与之对应的值Value,即<Key, Value>的键值对。该种方
式在现实生活中非常常见: (通过一个值查找另一个值)
比如英汉词典就是英文与中文的对应关系,通过英文可以快速找到与其对应的中文,英
文单词与其对应的中文<word, chinese>就构成一种键值对;
再比如统计单词次数,统计成功后,给定单词就可快速找到其出现的次数,单词与其出
现次数就是<word, count>就构成一种键值对。
还有如:通讯录
二叉搜索树的性能分析
插入和删除操作都必须先查找,查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树,若每个元素查找的概率相等,则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数,即结点越深,则比较次数越多。
但对于同一个关键码集合,如果各关键码插入的次序不同,可能得到不同结构的二叉搜索树:
最优情况下,二叉搜索树为完全二叉树(或者接近完全二叉树),其平均比较次数为:$log_2 N$ ($log_2 N$
)
最差情况下,二叉搜索树退化为单支树(或者类似单支),其平均比较次数为:$\frac{N}{2}$ ($\frac{N}{2}$
)
二叉搜索树的操作
查找
- 从根开始比较,查找,比根大则往右边走查找,比根小则往左边走查找。
- 最多查找高度次,走到到空,还没找到,这个值不存在。
插入
- 树为空,则直接新增节点,赋值给root指针(第一个节点就是root)
- 树不空,按二叉搜索树性质查找插入位置,插入新节点
特别地
同样一组数据,插入顺序不同,得到的二叉树也不同
当插入的值已存在时,插入失败(不考虑multi)
删除
首先查找元素是否在二叉搜索树中,如果不存在,则返回.
否则,根据树的结构定义,可以得到3种情况
- 要删除的结点无孩子结点
- 要删除的结点只有左孩子或右孩子时
- 要删除的结点有左、右孩子结点
看起来有待删除节点有4中情况,实际情况:
要删除的结点无孩子结点时,直接删除
要删除的结点只有左孩子或右孩子时,将左孩子或右孩子给父亲
要删除的结点可能是父亲的左孩子或者是右孩子,有2*2种情况(要删除的结点是父亲的左孩子或右孩子)
左右孩子都是空时,也满足情况,因此可以合并无孩子结点情况
在1的前提下,恰好是根节点,也是一种情况(让另外一个孩子做根即可)
要删除的结点有左右孩子(子树)时,需要找一个既要比左子树大也要比右子树小的节点来补上.
根据递归定义得知,只有左孩子的最右结点和右孩子的最左结点符合条件,二选一即可
当选择使用右孩子的最左结点时,有以下三种情况(与是不是根无关)
要删除的结点的右子树的最小结点恰好是要删除结点的右孩子.
要删除的结点的右子树的最小结点没有右孩子.
要删除的结点的右子树的最小结点有右孩子
(上图举例分析)
代码实现
BSTree.hpp
template<class K>
struct BSTreeNode {
BSTreeNode<K>* _left;
BSTreeNode<K>* _right;
K _key;
BSTreeNode(K key)
:_key(key),_left(nullptr),_right(nullptr)
{}
};
template<class K>
class BSTree {
public:
using Node = BSTreeNode<K>;
BSTree() = default;
BSTree(const BSTree& bst) {
_root = Copy(bst._root);
}
BSTree<K>& operator=(BSTree bst) { //拷贝复用
swap(_root,bst.root);
return *this;
}
~BSTree() {
Destroy(_root);
}
public:
bool Insert(const K& key) {
if (_root == nullptr) {
_root = new Node(key);
_root->_key = key;
return true;
}
BSTreeNode<K>* cur = _root;
BSTreeNode<K>* parent = _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;
}
}
//走出循环,说明树中不存在该节点, 可以插入
cur = new BSTreeNode<K>(key);
if (key < parent->_key) {
parent->_left = cur;
}
else {
parent->_right = cur;
}
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) {
if (_root == nullptr) return false;
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) {
_root = cur->_right;
}
else if (parent->_left == cur) {
parent->_left = cur->_right;
}
else {
parent->_right = cur->_right;
}
delete cur;
return true;
}
//没有右孩子
else if (cur->_right == nullptr) {
if (cur == _root) {
_root = cur->_left;
}
if (parent->_left == cur) {
parent->_left = cur->_left;
}
else {
parent->_right = cur->_left;
}
delete cur;
return true;
}
//有左右孩子
else {
//找右孩子(子树)的最小结点/最左结点
Node* rightMin = cur->_right; //明确不为空
Node* rightMinParent = cur;
while (rightMin->_left) {
rightMinParent = rightMin;
rightMin = rightMin->_left;
}
// 删除右子树最小结点有3种情况(与是不是根无关)
//1. 要删除的结点右子树最小结点恰好是自己的右孩子.
//2. 要删除的结点的右孩子的左子树的最左结点没有右孩子.
//3. 要删除的结点的右孩子的左子树的最左结点有右孩子.
//结论解析: 复用删除单结点代码,进行删除rightMin即可
K tmp = rightMin->_key;
Erase(rightMin->_key); //只能从根开始遍历,性能损失,但是二分查找很快,损失不大(理想情况,BST只学习用)
cur->_key = tmp;
return true;
} //有左右孩子的情况
} //找到了_继续处理的过程
}//循环找的过程
//循环结束,说明没找到
return false;
}//Erase [end]
void InOrder() {
_InOrder(_root);
std::cout << std::endl;
}
bool InsertR(const K& key) {
_InsertR(_root, key);
}
bool EraseR(const K& key) {
return _EraseR(_root,key);
}
private:
//此处返回值不能使用指针引用,虽然一定情况下可以使用(不推荐),至少目前不能引用空值.
Node* Copy(const Node* root) {
if (root == nullptr) {
return nullptr;
}
Node* newRoot = new Node(root->_key);
newRoot->_left = Copy(root->_left);
newRoot->_right = Copy(root->_right);
return newRoot;
}
//用不用引用无所谓,好习惯做到底
//(析构子节点时,父节点两个成员会成为垂悬指针,但是接下来父亲也要析构了,指针变量也随之回收)
void Destroy(Node*&root) {
if (root == nullptr) {
return ;
}
Destroy(root->_left);
Destroy(root->_right);
std::cout<<root->_key<<" ";
delete root; //释放加自动置空
}
//练习递归+引用 -- 代码更加简洁
bool _EraseR(Node*& root, const K&key) {
//走到空,说明没找到,返回false
if (root == nullptr) {
return false;
}
//大于走右边,小于走左边
if (key > root->_key) {
return _EraseR(root->_right,key);
}
else if(key<root->_key) {
return _EraseR(root->_left,key);
}
//找到了
else {
if (root->_left == nullptr) {
Node* del = root;
root = root->_right;
delete del;
return true;
}
else if (root->_right == nullptr) {
Node* del = root;
root = root->_left;
delete del;
return true;
}
//有左右孩子
else {
Node* leftMax = root->_left;
//找左子树最大结点
while (leftMax->_right) {
leftMax = leftMax->_right;
}
std::swap(root->_key, leftMax->_key);
return _EraseR(root->_left, key); //直接从左孩子开始递归删除.
}
}
}
//练习递归+引用指针的玩法,仅练习
bool _InsertR(Node*& root, const K& key) { //引用的妙用,跨栈帧直接访问实参
if (root == nullptr) {
root == new Node(key);
return true;
}
if (key == root->_key) return false;
return (key > root->_key) ? _InsertR(root->_right, key) : _InsertR(root->_left, key);
}
void _InOrder(Node* root) {
if (root == nullptr) return;
_InOrder(root->_left);
std::cout << root->_key << " ";
_InOrder(root->_right);
}
private:
BSTreeNode<K>* _root = nullptr;
};
test.cc
void test() {
int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
BSTree<int> bst;
for (int i : a) {
bst.Insert(i);
}
bst.InOrder();
////Find
//std::cout << std::boolalpha << bst.Find(8) << std::endl; //true
//std::cout << std::boolalpha << bst.Find(9) << std::endl; //false
BSTree<int> cp(bst);
cp.InOrder();
//测试两孩子的三种情况即可
bst.Erase(8); //1. 要删除的结点的右子树的最小结点恰好是要删除结点的右孩子.
bst.Erase(10); //2. 要删除的结点的右子树的最小结点没有右孩子
bst.Insert(5); //构造有右孩子的最小结点
bst.Erase(3); //3. 要删除的结点的右子树的最小结点有右孩子
bst.Erase(4);
bst.Erase(7);
bst.Erase(1);
bst.Erase(14);
bst.Erase(13);
bst.Erase(6);
bst.Erase(5);
bst.InOrder();
//禁止显式调用析构函数 --> 双重释放
//bst.~BSTree();
//cp.~BSTree();
}
int main() {
test();
}
BST 二叉搜索树 BinarySearchTree C++实现(递归/非递归)的更多相关文章
- 二叉搜索树的结构(30 分) PTA 模拟+字符串处理 二叉搜索树的节点插入和非递归遍历
二叉搜索树的结构(30 分) PTA 模拟+字符串处理 二叉搜索树的节点插入和非递归遍历 二叉搜索树的结构(30 分) 二叉搜索树或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则 ...
- 二叉搜索树的结构(30 分) PTA 模拟+字符串处理 二叉搜索树的节点插入和非递归遍历
二叉搜索树的结构(30 分) 二叉搜索树或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值:若它的右子树不空,则右子树上所有结点的值均大于它的根 ...
- 数据结构中很常见的各种树(BST二叉搜索树、AVL平衡二叉树、RBT红黑树、B-树、B+树、B*树)
数据结构中常见的树(BST二叉搜索树.AVL平衡二叉树.RBT红黑树.B-树.B+树.B*树) 二叉排序树.平衡树.红黑树 红黑树----第四篇:一步一图一代码,一定要让你真正彻底明白红黑树 --- ...
- [LeetCode] Serialize and Deserialize BST 二叉搜索树的序列化和去序列化
Serialization is the process of converting a data structure or object into a sequence of bits so tha ...
- 二叉搜索树BinarySearchTree(C实现)
头文件—————————————————————————————— #ifndef _BINARY_SEARCH_TREE_H_ #define _BINARY_SEARCH_TREE_H_ #inc ...
- [LeetCode] Minimum Absolute Difference in BST 二叉搜索树的最小绝对差
Given a binary search tree with non-negative values, find the minimum absolute difference between va ...
- bst 二叉搜索树简单实现
//数组实现二叉树: // 1.下标为零的元素为根节点,没有父节点 // 2.节点i的左儿子是2*i+1:右儿子2*i+2:父节点(i-1)/2: // 3.下标i为奇数则该节点有有兄弟,否则又左兄弟 ...
- 数据结构中常见的树(BST二叉搜索树、AVL平衡二叉树、RBT红黑树、B-树、B+树、B*树)
树 即二叉搜索树: 1.所有非叶子结点至多拥有两个儿子(Left和Right): 2.所有结点存储一个关键字: 非叶子结点的左指针指向小于其关键字的子树,右指针指向大于其关键字的子树: 如: BST树 ...
- Leetcode938. Range Sum of BST二叉搜索树的范围和
给定二叉搜索树的根结点 root,返回 L 和 R(含)之间的所有结点的值的和. 二叉搜索树保证具有唯一的值. 示例 1: 输入:root = [10,5,15,3,7,null,18], L = 7 ...
- 浅析BST二叉搜索树
2020-3-25 update: 原洛谷日报#2中代码部分出现一些问题,详情见此帖.并略微修改本文一些描述,使得语言更加自然. 2020-4-9 update:修了一些代码的锅,并且将文章同步发表于 ...
随机推荐
- Linux 特权 SUID/SGID 的详解
导航 0 前言 1 权限匹配流程 2 五种身份变化 3 有效用户/组 4 特权对 Shell 脚本无效 5 Sudo 与 SUID/SGID 的优先级 6 SUID.SGID.Sticky 各自的功能 ...
- 如何在不能求逆的时候做子集卷积 exp(即便能求逆也比常见方法优雅)
为什么要求逆?正常做子集卷积 exp 的时候递推求 \(G=\exp(F)\) 的系数时要用. 什么情况下不能求逆?模 \(2^{64}\),或者压根不取模. 我们可能会想,算出来肯定除得尽啊,因为组 ...
- GUI测试
标签(空格分隔): GUI 我要用到 Chrome 浏览器,所以需要先下载 Chrome Driver 并将其放入环境变量.接下来,你可以用自己熟悉的方式建立一个空的 Maven 项目,然后在 POM ...
- java中的即时编译(JIT)简介
Java发展这么多年一直长青,很大一部分得益于开发人员长期对其坚持不懈的优化:写得更少,跑得更快!JIT就是其中一项十分重要的优化. JIT全程Java Intime Compiler,即Java即时 ...
- 说说你对 SPA 单页面的理解,它的优缺点分别是什么?
SPA( single-page application )仅在 Web 页面初始化时加载相应的 HTML.JavaScript 和 CSS. 一旦页> 面加载完成,SPA 不会因为用户的操作而 ...
- 做独立开发者,能在 AppStore 赚到多少钱?
成为一名独立开发者,不用朝九晚五的上班,开发自己感兴趣的产品,在AppStore里赚美金,这可能是很多程序员的梦想,今天就来盘一盘,这个梦想实现的概率有多少. (Solo社区 投稿) 先来了解一些数据 ...
- 基于 Impala 的高性能数仓实践之物化视图服务
本文将主要介绍 NDH Impala 的物化视图实现. 接上篇,前两篇分别讲了执行引擎和虚拟数仓,它们是让一个 SQL 又快又好地执行的关键.但如果某些 SQL 过于复杂,比如多张大表进行 Join ...
- webpack4.15.1 学习笔记(十) — 常见 loader 使用
目录 style -loader <= css-loader <= less-loader postcss-loader file-loader url-loader html-withi ...
- [oeasy]python019_ 如何在github仓库中进入目录_找到程序代码_找到代码
继续运行 回忆上次内容 上上次 真写了万行代码 这 万行代码 都是写在明面上的 这次 使用git命令 下载了 github上面的仓库 添加图片注释,不超过 140 字(可选) 下载仓库 ...
- 二分查找 | C++
以此题为例:P2249 [深基13.例1]查找 二分查找 对于一个单调不降的序列 \(S\),传统查找的复杂度是 \(O(|S|)\),即 \(O(n)\). 有时候序列 \(S\) 中的元素特别多, ...