目录
一、二叉搜索树
1、二叉搜索树的概念
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
1、若它的左子树不为空，则左子树上所有节点的值都小于根节点的值；
2、若它的右子树不为空，则右子树上所有节点的值都大于根节点的值；
3、它的左右子树也分别为二叉搜索树。
如下图所示的二叉搜索树：
此二叉搜索树完全满足上面的三条性质。左子树的所有节点的值都小于根节点的值，右子树的所有节点的值都大于根节点的值，并且左右子树分别又是二叉搜索树。
2、二叉搜索树的节点设置
二叉搜索树的节点，在c++中可以用类来定义，类中的成员变量：一个指向左子树的指针变量，一个指向右子树的指针变量，一个存储数据的变量。
代码如下所示：
//该类为二叉树的节点
template<class K>
struct BSTreeNode
{
//节点里的左指针指向左节点，右指针指向右节点
//以及存放的数据内容
BSTreeNode<K>* _left;
BSTreeNode<K>* _right;
K _key;
//构造函数
BSTreeNode(const K& key)
:_left(nullptr) //初始化列表
, _right(nullptr)
, _key(key)
{}
};可以看到在该类里，用了一个类模板参数K，是因为这样就可以使得二叉搜索树里存放数据类型的多变，可以根据需要存储任意需要的数据类型，比如int、short、指针等等类型。
3、二叉搜索树的数据插入
在二叉搜索树中插入一个数据，那么插入后，二叉搜索树的性质不能改变，也必须满足上面的三条性质。
所以可以分为两种情况来进行插入：
1、当树为空的时候，那么新插入的这个数据，就会变成该树的根节点；
2、当树不为空的时候，那么按二叉搜索树性质查找插入位置，插入新的数据。
代码实现如下：
//类BSTree：搜索二叉树
//class BinarySearchTree
template<class K>
class BSTree
{
//类类型名重定义
typedef BSTreeNode<K> Node;
public:
//插入一个数据，并返回是否成功插入
bool Insert(const K& key)
{
//指向搜索二叉树的根节点的指针是空，说明是一个空树，
if (_root == nullptr)
{
//将插入的新节点的地址赋给指向根节点的指针即可
_root = new Node(key);
return true;
}
Node* parent = nullptr;
Node* cur = _root;
while (cur)//走到nullptr就结束循环
{
//因为搜索二叉树的特性，
//节点里的数据比要插入的数据key小，就往右下走；
//节点里的数据比要插入的数据key大，就往左下走；
if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else
{
//因为搜索二叉树的特性，没有相等的数据在里面，
//直接返回false
return false;
}
}
//创建一个新节点，并用指针cur指向这个节点
cur = new Node(key);
//将新节点与二叉搜索树进行链接
if (parent->_key < key)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
return true;
}
pravite:
//该类的成员变量，指向二叉搜索树根节点的指针
Node* _root;
};4、二叉搜索树的查找数据
与插入数据一样，通过二叉搜索树的性质进行数据的查找，相较于插入数据而言，查找数据反而简单一些，只需要通过对比二叉树节点的值 与 所给值得大小即可。
代码实现如下：
//类BSTree：搜索二叉树
//class BinarySearchTree
template<class K>
class BSTree
{
//类类型名重定义
typedef BSTreeNode<K> Node;
public:
//给一个数据，查找并返回该节点的地址
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
//根据搜索二叉树的特性，
//节点里的数据比要查找的数据key小，就往右下走；
//节点里的数据比要查找的数据key大，就往左下走；
if (cur->_key < key)
{
cur = cur->_right;
}
else if (cur->_key > key)
{
cur = cur->_left;
}
else
{
//找到了，就返回指向该节点的指针
return cur;
}
}
//循环结束都没有返回，那么就没有该节点，返回nullptr
return nullptr;
}
pravite:
//该类的成员变量，指向二叉搜索树根节点的指针
Node* _root;
};5、二叉搜索树的删除数据
首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：
1. 要删除的结点无孩子结点
2. 要删除的结点只有左孩子结点
3. 要删除的结点只有右孩子结点
4. 要删除的结点有左、右孩子结点
代码实现如下：
//类BSTree：搜索二叉树
//class BinarySearchTree
template<class K>
class BSTree
{
//类类型名重定义
typedef BSTreeNode<K> Node;
public:
//删除某个节点
bool Erase(const K& key)
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)//找到删除的节点
{
//根据搜索二叉树的特性，
//节点里的数据比要删除的数据key小，就往右下走；
//节点里的数据比要删除的数据key大，就往左下走；
if (cur->_key < key)
{
//走下一节点的时候，用parent记录下该节点
parent = cur;
cur = cur->_right;
}
else if (cur->_key > key)
{
//走下一节点的时候，用parent记录下该节点
parent = cur;
cur = cur->_left;
}
else //相等
{
// 开始删除，删除的这个节点有3种情况：
// 1、删除的这个节点 左为空
// 2、删除的这个节点 右为空
// 3、删除的这个节点 左右都不为空
//1、删除的这个节点 左为空
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;
cur = nullptr;
}
/// 2、删除的这个节点 右为空
else if (cur->_right == nullptr)
{
//特殊情况：删除的节点是根节点
if (_root == cur)
{
_root = cur->_left;
}
else //排除上面的特殊情况后
{
if (cur == parent->_left) //删除的节点是父节点的左节点
{
//将删除节点的父节点与删除节点的右节点链接起来
parent->_left = cur->_left;
}
else //删除的节点是父节点的右节点
{
//将删除节点的父节点与删除节点的右节点链接起来
parent->_right = cur->_left;
}
}
//链接好后，将需要删除的节点删除
delete cur;
cur = nullptr;
}
3、删除的这个节点 左右都不为空——用替换法
else
{
// 这里用找到右子树最小节点进行替换,
//右子树最小节点 就是 右子树的最左节点
//找最小节点，同时也要记录最小节点的父节点，
//方便后面删除最小节点后 进行链接
Node* minParent = cur;
Node* min = cur->_right;
//一直找最左边的节点，直到没有左节点
while (min->_left)
{
//每次找都要更新下最小节点的父节点
minParent = min;
min = min->_left;
}
//交换要删除节点和替换节点里的数据
swap(cur->_key, min->_key);
//分情况进行链接
//min是其父节点的左孩子
if (minParent->_left == min)
minParent->_left = min->_right;
else //min是其父节点的右孩子
minParent->_right = min->_right;
//删除掉替换节点
delete min;
min = nullptr;
}
return true;
}
}
//没找到删除的节点就返回false
return false;
}
pravite:
//该类的成员变量，指向二叉搜索树根节点的指针
Node* _root;
};解释看图片和代码注释，非常详细。
6、搜索二叉树的中序遍历
因为搜索二叉树的性质，所以搜索二叉树的中序遍历出来的数据是一个升序，这是这棵树有意义的地方，而前序遍历 和 后序遍历是一个乱序，所以我们这里只考虑中序遍历。
中序遍历的顺序：左子树 右子树 根
代码如下所示：
//类BSTree：搜索二叉树
//class BinarySearchTree
template<class K>
class BSTree
{
//类类型名重定义
typedef BSTreeNode<K> Node;
public:
void InOrder()
{
_InOrder(_root);
cout << endl;
}
private:
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_key; //<< ":" << root->_value << endl;
_InOrder(root->_right);
}
//该类的成员变量，指向二叉搜索树根节点的指针
Node* _root;
};在公共里，对私有的成员函数_InOrder()进行封装，就可以用中序遍历了成为一个公共的成员函数InOrder(),这样外部用InOrder()这个成员函数的时候，就可以用this指针了。
是因为中序遍历是一个递归，不能用this指针进行递归，所以在这里定义成私有，然后在公共里，对其进行一个封装。
7、上面功能总代码的实现
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
namespace Key
{
//定义这个类BSTreeNode，是二叉树的节点
template<class K>
struct BSTreeNode
{
//节点里的左指针指向左节点，右指针指向右节点
//以及存放的数据内容
BSTreeNode<K>* _left;
BSTreeNode<K>* _right;
K _key;
//构造函数
BSTreeNode(const K& key)
:_left(nullptr) //初始化列表
, _right(nullptr)
, _key(key)
{}
};
//定义这个类BSTree，是搜索二叉树
//class BinarySearchTree
template<class K>
class BSTree
{
//类类型名字太长，重定义
typedef BSTreeNode<K> Node;
public:
//插入一个数据，并返回是否成功插入
bool Insert(const K& key)
{
//指向搜索二叉树的根节点的指针是空，说明是一个空树，
//所以创建一个指向 通过该数据创建的节点 的指针即可
if (_root == nullptr)
{
_root = new Node(key);
//直接返回正确即可
return true;
}
//这个parent指针是为了找到插入的位置后，可以链接上二叉树
Node* parent = nullptr;
Node* cur = _root;//从根节点往下走，_root是指向根节点的指针
while (cur)
{
//因为搜索二叉树的特性，
//节点里的数据比要插入的数据key小，就往右下走；
//节点里的数据比要插入的数据key大，就往左下走；
if (cur->_key < key)
{
//每次往下走，都记录一下该节点，因为是下一个节点的父节点
//用指针parent指向该节点
parent = cur;
cur = cur->_right;
}
else if (cur->_key > key)
{
//每次往下走，都记录一下该节点，因为是下一个节点的父节点
//用指针parent指向该节点
parent = cur;
cur = cur->_left;
}
else
{
//因为搜索二叉树的特性，没有相等的数据在里面，
//直接返回false
return false;
}
}
//创建一个节点
cur = new Node(key);
//下面是是通过parent链接该节点
if (parent->_key < key)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
//最后返回ture
return true;
}
//给一个数据，查找并返回该节点的地址
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
//根据搜索二叉树的特性，
//节点里的数据比要查找的数据key小，就往右下走；
//节点里的数据比要查找的数据key大，就往左下走；
if (cur->_key < key)
{
cur = cur->_right;
}
else if (cur->_key > key)
{
cur = cur->_left;
}
else
{
//找到了，就返回指向该节点的指针
return cur;
}
}
//循环结束都没有返回，那么就没有该节点，返回nullptr
return nullptr;
}
//删除某个节点
bool Erase(const K& key)
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
//根据搜索二叉树的特性，
//节点里的数据比要删除的数据key小，就往右下走；
//节点里的数据比要删除的数据key大，就往左下走；
if (cur->_key < key)
{
//走下一节点的时候，用parent记录下该节点
parent = cur;
cur = cur->_right;
}
else if (cur->_key > key)
{
//走下一节点的时候，用parent记录下该节点
parent = cur;
cur = cur->_left;
}
else //相等
{
// 开始删除，删除的这个节点有3种情况：
// 1、删除的这个节点 左为空
// 2、删除的这个节点 右为空
// 3、删除的这个节点 左右都不为空
//1、删除的这个节点 左为空
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;
cur = nullptr;
}
/// 2、删除的这个节点 右为空
else if (cur->_right == nullptr)
{
//删除的节点是根节点
if (_root == cur)
{
_root = cur->_left;
}
else //排除上面的特殊情况后
{
if (cur == parent->_left) //删除的节点是父节点的左节点
{
//将删除节点的父节点与删除节点的右节点链接起来
parent->_left = cur->_left;
}
else //删除的节点是父节点的右节点
{
//将删除节点的父节点与删除节点的右节点链接起来
parent->_right = cur->_left;
}
}
//链接好后，将需要删除的节点删除
delete cur;
cur = nullptr;
}
3、删除的这个节点 左右都不为空——用替换法
else
{
// 这里用第一种找到右子树最小节点进行替换,
//右子树最小节点 就是 右子树的最左节点
//找最小节点，同时也要记录最小节点的父节点，
//方便后面删除最小节点后 进行链接
Node* minParent = cur;
Node* min = cur->_right;
//一直找最左边的节点，直到没有左节点
while (min->_left)
{
//每次找都要更新下最小节点的父节点
minParent = min;
min = min->_left;
}
//交换要删除节点和替换节点里的数据
swap(cur->_key, min->_key);
//分情况进行链接
//最小节点min是其父节点的左孩子
if (minParent->_left == min)
minParent->_left = min->_right;
//最小节点min是其父节点的右孩子
else
minParent->_right = min->_right;
//删除掉替换节点
delete min;
min = nullptr;
}
return true;
}
}
return false;
}
//中序遍历
void InOrder()
{
_InOrder(_root);
cout << endl;
}
private:
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_key; //<< ":" << root->_value << endl;
_InOrder(root->_right);
}
//指向搜索二叉树的根节点的指针
Node* _root = nullptr;
};需要注意的是：二叉搜索树是没有修改的功能，因为我们要保持搜索二叉树的性质，如果将数据进行了修改，那么就很有可能不在满足搜索二叉树的三条性质，所以我们时刻牢记它的三条性质。
二、搜索二叉树的KV模型
1、搜索二叉树的KV模型
搜索二叉树的KV模型，即搜索二叉树有两个类模板参数，一个K，一个V，类模板K就是二叉搜索树存储数据的类型，而类模板 V，是与K配对使用的另一个数据的类型，它更多的是起到辅助的作用。
比如我们在一个节点里存放了一个数据，那么如果这个数据会出现多次，那么这个时候类模板V的对象就是用于记录该数据次数的。
代码如下所示：
//二叉搜索树的KV结构
namespace KeyValue
{
//定义两个类模板参数K、V
template<class K, class V>
struct BSTreeNode
{
BSTreeNode<K, V>* _left;
BSTreeNode<K, V>* _right;
K _key; //存放了两个类型的数据，相比较与K模型
V _value;
BSTreeNode(const K& key, const V& value)
:_left(nullptr)
, _right(nullptr)
, _key(key)
, _value(value)
{}
};
//同样的，定义两个类模板参数K、V
//搜索二叉树依旧是按照K的数据进行排序，和V无关
template<class K, class V>
class BSTree
{
typedef BSTreeNode<K, V> Node;
public:
bool Insert(const K& key, const V& value)
{
if (_root == nullptr)
{
_root = new Node(key, value);
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, value);
if (parent->_key < key)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
return true;
}
//查找只和数据_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;
}
//删除只和数据_key有关，与数据_value无关
bool Erase(const K& key)
{
//...
return true;
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
private:
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_key << ":" << root->_value << endl;
_InOrder(root->_right);
}
private:
Node* _root = nullptr;
};
比如，我们来统计家具的个数：
2、二叉树搜索树的例子实现
//用改造二叉搜索树为KV结构来实现统计家具出现的次数
void TestBSTree2()
{
string arr[] = { "椅子", "桌子", "椅子", "沙发", "椅子", "椅子", "桌子", "沙发" };
BSTree<string, int> countTree;
for (auto& str : arr)
{
//BSTreeNode<string, int>* ret = countTree.Find(str);
auto ret = countTree.Find(str);
if (ret)
{
ret->_value++;
}
else
{
countTree.Insert(str, 1);
}
}
countTree.InOrder();
}
}代码结果如下：
128
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
