🔥个人主页：guoguoqiang. 🔥专栏：我与C++的爱恋
1.二叉搜索树介绍
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树
它在动态数据集合中维护了一定的排序顺序，以便实现快速的数据查找、插入和删除操作
左子树比根小，右子树比根大
对于二叉搜索树，进行中序遍历为升序
2.二叉搜索树的模拟和实现
首先我们构建节点：
template<class K>
struct BSTreeNode
{
K _key;
BSTreeNode<K>* _left;
BSTreeNode<K>* _right;
BSTreeNode()
:_key(K())
,_left(nullptr)
,_right(nullptr)
{}
BSTreeNode(const K& key)
: _key(key)
, _left(nullptr)
, _right(nullptr)
{}
};
每个节点有两个指针，分别指向它的左子节点和右子节点。如果子节点不存在，则这些指针为nullptr
1.默认构造函数
BSTreeNode()
:_key(K())
,_left(nullptr)
,_right(nullptr)
{}
默认构造函数，它初始化键值为K类型的默认值（通过调用K的默认构造函数），并将左右子节点指针都设置为nullptr，表示节点没有子节点
2.带参构造函数：
BSTreeNode(const K& key)
: _key(key)
, _left(nullptr)
, _right(nullptr)
{}
采用键值作为参数的构造函数，它会创建一个节点，这个节点的键值为传入的key值，同时初始化左右子节点指针为nullptr
template<class T>
class BSTree
{
public:
typedef BSTreeNode<T> Node;
private:
Node* _root = nullptr;
};
insert插入
比如插入5
bool Insert(const T& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_key < key)
{
cur = cur->_right;
}
else if (cur->_key > key)
{
cur = cur->_left;
}
else
{
return false;
}
}
return true;
}
比当前节点小，往左走，反之往右走，搜索树默认是不允许插入重复键值
所以遇到相同的直接返回false，但是最后一步插入，我们还需要父亲位置的节点来完成左边插入或者右边插入，所以我们需要一个父亲节点来记录位置：
bool Insert(const T& key)
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else
{
return false;
}
}
cur = new Node(key);
if (parent->_key < key)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
return true;
}
如果parent的键值小于插入的键值key，新节点被设置为父节点的右子树；否则设置为左子树
但是如果在这里_root为空树，parent也为空，而后面在判断时会对parent解引用而程序崩溃。
bool Insert(const T& key)
{
if (_root == nullptr)
{
_root = new Node(key);
return true;
}
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else
{
return false;
}
}
cur = new Node(key);
if (parent->_key < key)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
return true;
}
Find查找
bool Find(const T& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_key < key)
{
cur = cur->_right;
}
else if (cur->_key > key)
{
cur = cur->_left;
}
else
{
return true;
}
}
return false;
}
InOrder 中序遍历
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_key << " ";
_InOrder(root->_right);
}
Erase 删除
- **二叉搜索树的删除
首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：
a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点
看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程
如下：
情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除
情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除
情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题–替换法删除
中序前驱是它左子树中的最大节点，它小于该节点且最接近它。
中序后继是它右子树中的最小节点，它大于该节点且最接近它。
bool Erase(const T& key)
{
if (_root == nullptr)
return false;
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else
{
if (cur->_left == nullptr)
{
if (cur == _root)
{
_root = cur->_right;
}
else
{
if (cur == parent->_left)
{
parent->_left = cur->_right;
}
else
{
parent->_right = cur->_right;
}
}
delete cur;
}
else if (cur->_right == nullptr)
{
if (cur == _root)
{
_root = cur->_left;
}
else {
if (cur == parent->_left)
{
parent->_left = cur->_left;
}
else
{
parent->_right = cur->_left;
}
}
delete cur;
}
else
{
//左右都不为空，替换法删除
Node* rightminparent = cur;
Node* rightmin = cur->_right;
while (rightmin->_left)
{
rightminparent = rightmin;
rightmin = rightmin->_left;
}
cur->_key = rightmin->_key;
if (rightminparent->_left == rightmin)
{
rightminparent->_left = rightmin->_right;
}
else
{
rightminparent->_right = rightmin->_right;
}
delete rightmin;
}
return true;
}
}
return false;
}
二叉树的应用
1.K模型：
K模型指的是二叉树的节点仅存储键Key）信息，而没有与键相关联的特定“值”（Value）。换句话说，节点中的数据只有一个维度，节点的排序和组织就是基于这些键
在K模型的二叉树中，例如二叉搜索树（BST），节点的位置由其键的顺序决定。所有的节点操作，包括插入、查找和删除都是根据这个键来执行的。
比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误
2.KV模型：
KV模型指的是二叉树的节点存储“键值对”（Key-Value Pair）。这里“键”（Key）用于确定节点的位置跟顺序，“值”（Value）则是与键关联的数据。
在KV模型的二叉树中，节点依然是根据键的顺序进行排列和组织的，但是与每个键都有一个相对应的值。这种模式适用于情况更为复杂的场景，如实现映射或字典结构。
KV模型的一个典型例子是映射（Map）或词典（Dictionary）
比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对
template<class K,class V>
struct BSTreeNode
{
V _value;
K _key;
BSTreeNode<K,V>* _left;
BSTreeNode<K,V>* _right;
BSTreeNode()
:_key(K())
, _value(V());
, _left(nullptr)
, _right(nullptr)
{}
BSTreeNode(const K& key,const V& value)
: _key(key)
,_value(value)
, _left(nullptr)
, _right(nullptr)
{}
};
template<class K,class V>
class BSTree
{
public:
typedef BSTreeNode<K,V> Node;
bool Insert(const K& key,const V& value)
{........
cur = new Node(key,value);
........
}
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_key < key)
{
cur = cur->_right;
}
else if (cur->_key > key)
{
cur = cur->_left;
}
else
{
return cur;
}
}
return nullptr;
}
........
};
二叉树性能分析
插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为O(log n)
最差情况下，二叉搜索树退化为单支树(或者类似单支)，查找的时间复杂度为O(n)
后续还会有旋转啥的，期待后续的AVL树和红黑树的讲解。
本节内容到此结束！！感谢大家观看！！
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
