二叉搜索树
除了自己，任何人都无法给你力量
由于在大数据的查找中，由于我们普通的查找算法已经不满足我们日常的效率要求了，比如我们平时的折半查找算法，虽然效率是NlogN,但折半查找算法的前提是我们需要将其排序，但排序也同样耗费空间和效率，例如最快的排序算法时间复杂度为NlogN，此时效率还是低。此时我们就有了现在下面要讲的二叉搜索树。
🎓概念
二叉搜索树（BST）又称二叉查找树或二叉排序树。一棵二叉搜索树是以二叉树来组织的，可以使用一个二叉链表数据结构来表示，其中每一个结点就是一个对象。一般地，除了key和位置数据之外，每个结点还包含属性lchild(左孩子)、rchild(右孩子)，分别指向结点的左孩子、右孩子和双亲（父结点）。如果某个孩子结点，则相应属性的值为随机值。叶子结点的左右孩子结点指针都为nullptr。
🎓性质
叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
- 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值。
- 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值。
- 整棵树中每个结点都为二叉搜索树。
🎓二叉搜索树实现
🎃二叉搜索树key模型
在我们平时用的二叉搜索树中有着key模型和<key,V>模型。这里我们拿key模型为例。每个结点都需要一个要存储的类型，以及一个指向左孩子的指针和指向右孩子的指针。
//Key模型
template<class K>
class BSTreeNode
{
public:
//构造函数
BSTreeNode(const K&key):m_left(nullptr), m_right(nullptr),m_key(key)
{
}
BSTreeNode<K>* m_left; //指向左孩子的指针
BSTreeNode<K>* m_right; //指向右孩子的指针
K m_key; //每个结点的数据
};
🎃二叉搜索树插入
二叉搜索树的插入操作很简单，这里有几种情况：
- 当二叉搜索树中为空时，我们用头指针所在位置创建结点对象。
- 当二叉搜索树中不为空时：
-
- 1、当插入的key值比我们当前所在的位置的值大时，我们往右走；
-
- 2、当插入的key值比我们当前所在的位置的值小时，我们往左走；
-
- 3、当插入的key值与当前的值相等时，此时插入失败，由于二叉搜索树不允许有重复的数据，直接返回false；
非递归版本
bool insert(const K&key)
{
//当头指针为空时
if (m_root == nullptr)
{
m_root = new node(key);
return true;
}
//parent指针指向插入位置cur的父结点
//cur指向被插入的结点所在位置
node* parent = nullptr;
node* cur = m_root;
while (cur!=nullptr)
{
//判断当前的cur的key值与要插入的key值比较
//大就往右走，小就往左走。相等直接返回插入失败。
if (cur->m_key < key)
{
parent = cur;
cur = cur->m_right;
}
else if (cur->m_key > key)
{
parent = cur;
cur = cur->m_left;
}
else
{
return false;
}
}
//判断此时要插入的值是要插入到我们此时插入的结点的左边还是右边
if (parent->m_key < key)
{
//如果比我大，那么插入parent的右边
parent->m_right = new node(key);
}
else
{
//如果比我小，那么插入parent的左边
parent->m_left = new node(key);
}
//返回插入成功。
return true;
}
递归版本
这里的递归版本的插入，一定要理解此时的root形参指针是上一层该函数的root形参的m_left或root->m_right的一个引用，对此时的root的改变即是改变上一层的结点。
bool insertR(const K& key)
{
return _insertR(m_root, key);
}
//实现这个方法的关键是这个引用，当此时的root等于nullptr，相当于上一级的root->left或者root->right，此时被我们用该引用new node(key)
bool _insertR(node*& root, const K& key)
{
if (root == nullptr)
{
root = new node(key);
return true;
}
if (root->m_key < key)
{
return _insertR(root->m_right, key);
}
else if (root->m_key > key)
{
return _insertR(root->m_left, key);
}
else
{
return false;
}
}
🚀二叉搜索树查找
同样二叉搜索树的查找功能与插入操作思路相同，这里就不再赘述了。
非递归版本
bool find(const K& key)
{
if (m_root == nullptr)
{
return false;
}
node* cur = m_root;
while (cur != nullptr)
{
if (cur->m_key < key)
{
cur = cur->m_right;
}
else if (cur->m_key > key)
{
cur = cur->m_left;
}
else
{
return true;
}
}
return false;
}
递归版本
bool findR(const K& key)
{
return _findR(m_root, key);
}
bool _findR(const node* root,const K & key)
{
if (root == nullptr)
{
return false;
}
if (root->m_key < key)
{
return _findR(root->m_right, key);
}
else if (root->m_key > key)
{
return _findR(root->m_left, key);
}
else
{
return true;
}
}
⚽二叉搜索树遍历
二叉搜索树的遍历采用中序遍历，这就意味着遍历出来的结果天然就是有序的(默认是升序)。
非递归版本
void Inorder()
{
stack<node*>path;
node* cur = m_root;
while (cur != nullptr || !path.empty())
{
while (cur != nullptr)
{
path.push(cur);
cur = cur->m_left;
}
node* temp = path.top();
path.pop();
cout << temp->m_key << " ";
cur = temp->m_right;
}
cout << endl;
}
递归版本
void _Inorder(node *root)
{
if (root == nullptr)
{
return;
}
_Inorder(root->m_left);
cout << root->m_key << " ";
_Inorder(root->m_right);
}
void Inorder()
{
_Inorder(m_root);
cout << endl;
}
可能有人会疑惑为什么要写两个函数，直接用一个函数写完不就行了，干嘛那么麻烦写两个呢？
这是因为我们需要使用得私有成员m_root，在类外我们并不能直接使用它的私有成员。所以我们必须得写一个子函数来进行递归调用得到结果，上面的代码同理。
🥇二叉搜索树的判断
在上面我们已经创建好了二叉搜索树了，此时我们想要验证一下我们的二叉搜索树是不是真的满足二叉搜索树的性质，那么我们该怎么去判断呢？
首先在上面我们知道二叉搜索树中序遍历出来的结点的值是一个升序的。
那么我就利用该性质来书写代码。
思路：
首先我们先创建一个栈和一个临时变量prev，其中栈存储node * ，而prev存储的是上一个元素的值。我们只需要判断当前中序遍历出来的值是否比上一个结点的值要大呢？如果大的话说明该部分是二叉搜索树，否则不是。
bool _isBSTree( node*& root)
{
if (root == nullptr)
{
return true;
}
stack<node*>st;
node* cur = root;
int prev = INT_MIN + 1;
while (!st.empty() || cur != nullptr)
{
if (cur != nullptr)
{
st.push(cur);
cur = cur->m_left;
}
cur = st.top();
st.pop();
if (cur->m_key <= prev)
{
return false;
}
prev = cur->m_key;
cur = cur->m_right;
}
return true;
}
bool isBSTree()
{
return _isBSTree(m_root);
}
🚀二叉搜索树删除
在二叉搜索树中最难的操作就是删除，由于删除时要考虑到是否破坏二叉搜索树的结构和性质，当如果进行了破坏时，我们要进行旋转来使他重新恢复二叉搜索树的性质。
- 首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：
a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点
看起来有待删除节点有4中情况，实际情况是，a可以与情况b或者c合并起来，因此真正的删除过程如下：
情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点
情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点
情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题。
非递归版本
bool erase(const K& key)
{
//同样这里要判断头指针是否是空指针的情况，是的话直接返回删除失败false
if (m_root == nullptr)
{
return false;
}
node* cur = m_root;
node* parent = nullptr; //该结点有可能未空指针，造成错误，已解决
while (cur!=nullptr)
{
if (cur->m_key < key)
{
parent = cur;
cur = cur->m_right;
}
else if (cur->m_key > key)
{
parent = cur;
cur = cur->m_left;
}
else
{
//当这里的结点左右孩子都没有就无所谓了，让其随便进入 情况1 或者 2
if (cur->m_left == nullptr) //1、要删除的结点只有右孩子结点
{
if (parent != nullptr)
{
if (parent->m_right == cur) //如果你是的右孩子，那么我把我的 右指针 指向 你的右
{
parent->m_right = cur->m_right;
}
else
{
parent->m_left = cur->m_right; //如果你是的左孩子，那么我把我的 左指针 指向 你的右
}
}
else
{
m_root = cur->m_right;
}
delete cur;
cur =nullptr;
}
else if(cur->m_right==nullptr) //2、要删除的结点只有左孩子结点
{
if (parent != nullptr)
{
if (parent->m_left == cur) //同理 如果你是的左孩子，那么我把我的 左指针 指向 你的左
{
parent->m_left = cur->m_left;
}
else
{
parent->m_right = cur->m_left; //如果你是的右孩子，那么我把我的 左指针 指向 你的左
}
}
else
{
m_root = cur->m_left;
}
delete cur;
cur = nullptr;
}
else //3、要删除的结点有左、右孩子结点
{
node* rightmin = cur->m_right;
node* rightminparent = nullptr; //有可能空指针情况,已解决
while (rightmin->m_left != nullptr)
{
rightminparent = rightmin;
rightmin = rightmin->m_left;
}
if (rightminparent == nullptr)
{
cur->m_key = rightmin->m_key;
cur->m_right = rightmin->m_right;
}
else
{
cur->m_key = rightmin->m_key;
rightminparent->m_left = rightmin->m_right;
}
delete rightmin;
rightmin = nullptr; //记得要将删除的结点置为nullptr，否则造成空指针的情况
return true;
}
}
}
return false;
}
递归版本
bool eraseR(const K& key)
{
return _eraseR(m_root, key);
}
bool _eraseR(node*& root, const K& key)
{
if (root == nullptr)
{
return false;
}
if (root->m_key < key)
{
_eraseR(root->m_right, key);
}
else if (root->m_key > key)
{
_eraseR(root->m_left, key);
}
else
{
if (nullptr == root->m_left)
{
node* del = root;
root = root->m_right; //由于这里的root参数是&类型，这一句相当于是root的父亲结点parent的左右指针的一个被赋值为root->m_right
delete del;
del = nullptr;
}
else if (nullptr == root->m_right)
{
node* del = root;
root = root->m_left;
delete del;
del = nullptr;
}
else
{
node* Rightmin = root->m_right; //不能用root直接来遍历，不然会找不到此时的root的右子树
while (Rightmin->m_left != nullptr)
{
Rightmin = Rightmin->m_left;
}
K min = Rightmin->m_key; //转化思路：我们原来是要删除有左右子树的结点，转换成删除删除结点的右子树的最小节点
_eraseR(root->m_right, min);
root->m_key = min;
}
return true;
}
}
🍤二叉搜索树的拷贝构造
在这里由于二叉搜索树这个类中是含有指针变量的，如果直接使用编译器默认提供的浅拷贝会出错。所以我们需要进行深拷贝。
这里我们利用前序遍历的思路来进行深拷贝,动画演示如下：
node* copy(const node*root)
{
if (root == nullptr)
{
return nullptr;
}
node* copyNode = new node(root->m_key);
copyNode->m_left = copy(root->m_left);
copyNode->m_right = copy(root->m_right);
return copyNode;
}
BSTree(const BSTree<K> &obj)
{
m_root = copy(obj.m_root);
}
🌯二叉搜索树的operator=
与拷贝构造同理，都是需要深拷贝。这里我们直接定义个临时对象，让这个零时对象去调用拷贝构造函数，最后进行交换二叉搜索树的指针即可。
BSTree<K>& operator=(const BSTree<K>& obj)
{
if (this != &obj)
{
BSTree<K>temp = obj; //调用拷贝构造
std::swap(temp.m_root, this->m_root);
}
return *this;
}
🌮二叉搜索树的析构函数
析构函数要释放我们申请的内存空间，这里我们利用后序遍历的方式来释放一个个的结点。
~BSTree()
{
if (m_root == nullptr)
{
return;
}
node* cur = m_root;
node* prev = nullptr;
stack<node*>s;
while (cur != nullptr || !s.empty())
{
while (cur!= nullptr) //一直把左结点放进栈中
{
s.push(cur);
cur = cur->m_left;
}
cur = s.top();
s.pop();
//cur->m_right==prev 这个判断很重要，防止访问完右结点时，来回横跳
if (cur->m_right==nullptr||cur->m_right==prev)
{
prev = cur;
delete cur;
cur = nullptr;
}
else
{
s.push(cur);
cur = cur->m_right;
}
}
}
🎠二叉搜索树性能分析
插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的
深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：logN。
最差情况下，二叉搜索树退化为单支树，其平均比较次数为：N/2。此时就相当于是一个双向链表了，查找效率大幅度下降。
🎿二叉搜索树应用
-
K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
以单词集合中的每个单词作为key，构建一棵二叉搜索树在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。 -
KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。比如：实现一个简单的英汉词典dict，可以通过英文找到与其对应的中文，具体实现方式如下：
<单词，中文含义>为键值对构造二叉搜索树，注意：二叉搜索树需要比较，键值对比较时只比较Key查询英文单词时，只需给出英文单词，就可快速找到与其对应的key。
🎯注意
在二叉搜索树是没有修改这个选项的，由于当修改时，我们将其的key值(也就是常说的比较码)改变，那么我们的二叉搜索树的性质就会被破坏了
🎡完整代码实现
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stack>
using namespace std;
//Key模型
template<class K>
class BSTreeNode
{
public:
BSTreeNode(const K&key):m_left(nullptr), m_right(nullptr),m_key(key)
{
}
BSTreeNode<K>* m_left;
BSTreeNode<K>* m_right;
K m_key;
};
template<class K>
class BSTree
{
typedef BSTreeNode<K> node;
public:
BSTree():m_root(nullptr)
{
}
BSTree(const BSTree<K> &obj)
{
m_root = copy(obj.m_root);
}
BSTree<K>& operator=(const BSTree<K>& obj)
{
if (this != &obj)
{
BSTree<K>temp = obj; //调用拷贝构造
std::swap(temp.m_root, this->m_root);
}
return *this;
}
node* copy(const node*root)
{
if (root == nullptr)
{
return nullptr;
}
node* copyNode = new node(root->m_key);
copyNode->m_left = copy(root->m_left);
copyNode->m_right = copy(root->m_right);
return copyNode;
}
~BSTree()
{
if (m_root == nullptr)
{
return;
}
node* cur = m_root;
node* prev = nullptr;
stack<node*>s;
while (cur != nullptr || !s.empty())
{
while (cur!= nullptr) //一直把左结点放进栈中
{
s.push(cur);
cur = cur->m_left;
}
cur = s.top();
s.pop();
//cur->m_right==prev 这个判断很重要，防止访问完右结点时，来回横跳
if (cur->m_right==nullptr||cur->m_right==prev)
{
prev = cur;
delete cur;
cur = nullptr;
}
else
{
s.push(cur);
cur = cur->m_right;
}
}
}
bool insert(const K&key)
{
if (m_root == nullptr)
{
m_root = new node(key);
return true;
}
node* parent = nullptr;
node* cur = m_root;
while (cur!=nullptr)
{
if (cur->m_key < key)
{
parent = cur;
cur = cur->m_right;
}
else if (cur->m_key > key)
{
parent = cur;
cur = cur->m_left;
}
else
{
return false;
}
}
if (parent->m_key < key)
{
parent->m_right = new node(key);
}
else
{
parent->m_left = new node(key);
}
return true;
}
bool find(const K& key)
{
if (m_root == nullptr)
{
return false;
}
node* cur = m_root;
while (cur != nullptr)
{
if (cur->m_key < key)
{
cur = cur->m_right;
}
else if (cur->m_key > key)
{
cur = cur->m_left;
}
else
{
return true;
}
}
return false;
}
void Inorder()
{
stack<node*>path;
node* cur = m_root;
while (cur != nullptr || !path.empty())
{
while (cur != nullptr)
{
path.push(cur);
cur = cur->m_left;
}
node* temp = path.top();
path.pop();
cout << temp->m_key << " ";
cur = temp->m_right;
}
cout << endl;
}
bool erase(const K& key)
{
if (m_root == nullptr)
{
return false;
}
node* cur = m_root;
node* parent = nullptr; //该结点有可能未空指针，造成错误，已解决
while (cur!=nullptr)
{
if (cur->m_key < key)
{
parent = cur;
cur = cur->m_right;
}
else if (cur->m_key > key)
{
parent = cur;
cur = cur->m_left;
}
else
{
//当这里的结点左右孩子都没有就无所谓了，让其随便进入 情况1 或者 2
if (cur->m_left == nullptr) //1、要删除的结点只有右孩子结点
{
if (parent != nullptr)
{
if (parent->m_right == cur) //如果你是的右孩子，那么我把我的 右指针 指向 你的右
{
parent->m_right = cur->m_right;
}
else
{
parent->m_left = cur->m_right; //如果你是的左孩子，那么我把我的 左指针 指向 你的右
}
}
else
{
m_root = cur->m_right;
}
delete cur;
cur =nullptr;
}
else if(cur->m_right==nullptr) //2、要删除的结点只有左孩子结点
{
if (parent != nullptr)
{
if (parent->m_left == cur) //同理 如果你是的左孩子，那么我把我的 左指针 指向 你的左
{
parent->m_left = cur->m_left;
}
else
{
parent->m_right = cur->m_left; //如果你是的右孩子，那么我把我的 左指针 指向 你的左
}
}
else
{
m_root = cur->m_left;
}
delete cur;
cur = nullptr;
}
else //3、要删除的结点有左、右孩子结点
{
node* rightmin = cur->m_right;
node* rightminparent = nullptr; //有可能空指针情况,已解决
while (rightmin->m_left != nullptr)
{
rightminparent = rightmin;
rightmin = rightmin->m_left;
}
if (rightminparent == nullptr)
{
cur->m_key = rightmin->m_key;
cur->m_right = rightmin->m_right;
}
else
{
cur->m_key = rightmin->m_key;
rightminparent->m_left = rightmin->m_right;
}
delete rightmin;
rightmin = nullptr;
return true;
}
}
}
return false;
}
public:
bool eraseR(const K& key)
{
return _eraseR(m_root, key);
}
private:
bool _eraseR(node*& root, const K& key)
{
if (root == nullptr)
{
return false;
}
if (root->m_key < key)
{
_eraseR(root->m_right, key);
}
else if (root->m_key > key)
{
_eraseR(root->m_left, key);
}
else
{
if (nullptr == root->m_left)
{
node* del = root;
root = root->m_right; //由于这里的root参数是&类型，这一句相当于是root的父亲结点parent的左右指针的一个被赋值为root->m_right
delete del;
del = nullptr;
}
else if (nullptr == root->m_right)
{
node* del = root;
root = root->m_left;
delete del;
del = nullptr;
}
else
{
node* Rightmin = root->m_right; //不能用root直接来遍历，不然会找不到此时的root的右子树
while (Rightmin->m_left != nullptr)
{
Rightmin = Rightmin->m_left;
}
K min = Rightmin->m_key; //转化思路：我们原来是要删除有左右子树的结点，转换成删除删除结点的右子树的最小节点
_eraseR(root->m_right, min);
root->m_key = min;
}
return true;
}
}
public:
bool isBSTree()
{
return _isBSTree(m_root);
}
private:
bool _isBSTree(node*& root) const
{
if (root == nullptr)
{
return true;
}
stack<node*>st;
node* cur = root;
int prev = INT_MIN + 1;
while (!st.empty() || cur != nullptr)
{
if (cur != nullptr)
{
st.push(cur);
cur = cur->m_left;
}
cur = st.top();
st.pop();
if (cur->m_key <= prev)
{
return false;
}
prev = cur->m_key;
cur = cur->m_right;
}
return true;
}
public:
void InorderR()
{
_InorderR(m_root);
cout << endl;
}
private:
void _InorderR(node* root)
{
if (root == nullptr)
{
return;
}
_InorderR(root->m_left);
cout << root->m_key << " ";
_InorderR(root->m_right);
}
public:
bool findR(const K& key)
{
return _findR(m_root, key);
}
private:
bool _findR(const node* root,const K & key)
{
if (root == nullptr)
{
return false;
}
if (root->m_key < key)
{
return _findR(root->m_right, key);
}
else if (root->m_key > key)
{
return _findR(root->m_left, key);
}
else
{
return true;
}
}
public:
bool insertR(const K& key)
{
return _insertR(m_root, key);
}
private:
//实现这个方法的关键是这个引用，当此时的root等于nullptr，相当于上一级的root->left或者root->right，此时被我们用该引用new node(key)
bool _insertR(node*& root, const K& key)
{
if (root == nullptr)
{
root = new node(key);
return true;
}
if (root->m_key < key)
{
return _insertR(root->m_right, key);
}
else if (root->m_key > key)
{
return _insertR(root->m_left, key);
}
else
{
return false;
}
}
private:
node* m_root; //搜索二叉树根结点
};
如果小伙伴还没看懂可以在评论区留言，我会在评论区给你解答！
如有错误之处还请各位指出！！！
那本篇文章就到这里啦，下次再见啦！
1215
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
