1、二叉树的概念
二叉查找树(Binary Search Tree),(又:二叉搜索树,二叉排序树)它或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值; 若它的右子树不空,则右子树上所有结点的值均大于它的根结点的值; 它的左、右子树也分别为二叉排序树
二叉排序树的查找过程和次优二叉树类似,通常采取二叉链表作为二叉排序树的存储结构。中序遍历二叉排序树可得到一个关键字的有序序列,一个无序序列可以通过构造一棵二叉排序树变成一个有序序列,构造树的过程即为对无序序列进行排序的过程。每次插入的新的结点都是二叉排序树上新的叶子结点,在进行插入操作时,不必移动其它结点,只需改动某个结点的指针,由空变为非空即可。搜索,插入,删除的复杂度等于树高,O( l o g 2 N log_2 N log2N)
2、二叉搜索树的实现
2.1 结点的定义和框架
//结点的模板
template<class K>
struct BSTreeNode
{
K _key;//存放数据
BSTreeNode<K>* _left;//左孩子指针
BSTreeNode<K>* _right;//右孩子指针
//构造函数,左孩子和右孩子默认给空
BSTreeNode(const K& key)
:_key(key)
, _left(nullptr)
, _right(nullptr)
{}
};
template<class K>
struct BSTree
{
typedef BSTreeNode<K> Node;//重命名
private:
Node* _root;
}
2.2 中序遍历
public:
void InOrder()
{
_InOrede(_root);
cout << endl;
}
private:
void _InOrede(Node* root)
{
if (root == nullptr)//为nullptr,则返回
return;
_InOrede(root->_left);//递归左
cout << root->_key << " ";
_InOrede(root->_right);//递归右
}
2.3 搜索(迭代和递归)
public:
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (key > cur->_key)//如果key比当前结点(cur->_key)的值大,则key在右子树
cur = cur->_right;
else if (key < cur->_key)//如果key比当前结点(cur->_key)的值小,则key在左子树
cur = cur->_left;
else
return root;//找到了,则返回true
}
return nullptr;//找不到,返回false
}
//给一个查找的接口,将实现放在private中
Node* FindR(const K& key)
{
return _FindR(_root, key);
}
private:
Node* _FindR(Node* root, const K& key)
{
if (root == nullptr)//走到nullptr了,则说明没有值为key的结点,返回nullptr
return nullptr;
if (key > root->_key)//如果key比当前结点(cur->_key)的值大,则递归右子树
_FindR(root->_right, key);
else if (key < root->_key)//如果key比当前结点(cur->_key)的值小,则递归左子树
_FindR(root->_left, key);//找到了,返回值为key的结点
return root;
}
2.4 插入(迭代和递归)
public:
bool Insert(const K& key)
{
if (_root == nullptr)
{
_root = new Node(key);
return true;
}
else
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)//寻找插入的位置
{
if (key > cur->_key)//key比cur大,说明要插入到右子树
{
parent = cur;
cur = cur->_right;
}
else if (key < cur->_key)//key比cur小,说明要插入到左子树
{
parent = cur;
cur = cur->_left;
}
else//如果要key已经存在,则不需要再插入,返回false
{
return false;
}
}
if (key > parent->_key)//key比parent大,插在右边
parent->_right = new Node(key);
else//key比parent小,插在左边
parent->_left = new Node(key);
}
return true;
}
//给一个插入的接口,实现放在private中
bool InsertR(const K& key)
{
return _InsertR(_root, key);
}
private:
bool _InsertR(Node* &root, const K& key)
{
if (root == nullptr)
{
root = new Node(key);
return true;
}
if (key > root->_key)//key比当前结点的值大,则说明应该插入到右子树当中
_InsertR(root->_right, key);
else if (key < root->_key)//key比当前结点的值下,则说明应该插入到左子树当中
_InsertR(root->_left, key);
return false;//走到这里,则说明树中已经存在结点的值和key相等的情况,则不需要插入,返回false
}
2.5 删除(迭代和递归)
public:
bool Erase(const K& key)
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (key > cur->_key)//key比cur大,在右边
{
parent = cur;
cur = cur->_right;
}
else if (key < cur->_key)//key比cur小,在左边
{
parent = cur;
cur = cur->_left;
}
else//找到了,然后进行删除
{
if (cur->_left == nullptr)
{
if (parent == nullptr)//处理cur为根节点,parent为nullptr的情况
{
_root = cur->_right;
}
else
{
if (parent->_right == cur)//cur是parent的右子树
parent->_right = cur->_right;//parent的右连接cur的右
else//cur是parent的左子树
parent->_left = cur->_right;//parent的左连接cur的右
}
delete cur;
}
else if (cur->_right == nullptr)
{
if (parent == nullptr)//处理cur为根节点,parent为nullptr的情况
{
_root = cur->_left;
}
else
{
if (parent->_right == cur)//cur是parent的右子树
parent->_right = cur->_left;//parent的右连接cur的左
else//cur是parent的左子树
parent->_left = cur->_left;//parent的左连接cur的左
}
delete cur;
}
else//cur的左右都不为nullptr,左子树最右节点或者右子树的最左结点
{
Node* min = cur->_right;
Node* minparent = cur;//也能处理min已经没有左子树,已经是最小结点的情况
while (min->_left)//找最小
{
minparent = min;
min = min->_left;
}
cur->_key = min->_key;//将min中的_key赋值给cur
if (minparent->_left == min)
minparent->_left = min->_right;//处理minparent的左结点是min的情况
else
minparent->_right = min->_right;//处理minparent的右结点是min的情况
delete min;
}
return true;
}
}
return false;//,如果走到这里,表示没有这个值
}
//给一个删除的接口,实现放在private中
bool EraseR(const K& key)
{
return _EraseR(_root, key);
}
private:
bool _EraseR(Node*& root, const K& key)
{
if (root == nullptr)//root为nullptr,则说明树中没有我们需要删除的值,返回false
return false;
if (key > root->_key)//递归右子树找key
_EraseR(root->_right, key);
else if (key < root->_key)//递归左子树找key
_EraseR(root->_left, key);
else//走到这一步,说明已经找到了,接下来就该进行删除操作
{
Node* del = root;//先将需要删除的结点保存起来
if (root->_left == nullptr)//如果需要删除的结点的左子树为nullptr,则只需要将root的右子树的根节点赋值root,改变了解关系即可
{
root = root->_right;
delete del;//释放del,放在内存泄漏
}
else if (root->_right == nullptr)//跟结点的左子树为nullptr的情况一样
{
root = root->_left;
delete del;
}
else//左子树和右子树都不为nullptr
{
Node* min = root->_right;
while (min->_left)
{
min = min->_left;
}
swap(min->_key, root->_key);//交换需要删除的值和右子树的最左结点的值
//递归root的右子树,最终会走到if (root->_left == nullptr)或者else if (root->_right == nullptr)进行删除
_EraseR(root->_right, key);
}
}
return true;//走到这里,则说明删除结点成功
}
迭代过程的图解(cur为我们需要删除的结点):
cur的左子树为nullptr
第一种情况,parent == nullptr
第二种情况,parent->_right == cur
第三种情况,parent->_left == cur
cur的右子树为nullptr和左子树为nullptr情况一样,只是方向相反而已
cur的左子树和右子树都不为nullptr,有两种解决方案:将左子树最右节点或者右子树的最左结点赋值给cur,再删除最右结点或者最左结点
我们选择右子树的最左结点
第一种情况,minparent->_right == min
第二种情况,minparent->_left == min
3、二叉搜索树的应用
1.K模型:K模型即只有key作为关键码,结构中只需要存储Key即可,关键码即为需要搜索到的值。
比如:给一个单词word,判断该单词是否拼写正确,具体方式如下:
- 以单词集合中的每个单词作为key,构建一棵二叉搜索树
- 在二叉搜索树中检索该单词是否存在,存在则拼写正确,不存在则拼写错误
2.KV模型:每一个关键码key,都有与之对应的值Value,即<Key, Value>的键值对。该种方式在现实生活中非常常见:比如英汉词典就是英文与中文的对应关系,通过英文可以快速找到与其对应的中文,英文单词与其对应的中文<word, chinese>就构成一种键值对;再比如统计单词次数,统计成功后,给定单词就可快速找到其出现的次数,单词与其出现次数就是<word, count>就构成一种键值对
比如:实现一个简单的英汉词典dict,可以通过英文找到与其对应的中文,具体实现方式如下:
- <单词,中文含义>为键值对构造二叉搜索树,注意:二叉搜索树需要比较,键值对比较时只比较Key
- 查询英文单词时,只需给出英文单词,就可快速找到与其对应的key
对于KV模型,我们只需要在模板中多添加一个参数,在其他的地方稍作修改即可
template<class K, class V>
struct BSTreeNode
{
K _key;
V _value;
BSTreeNode<K, V>* _left;
BSTreeNode<K, V>* _right;
BSTreeNode(const K& key, const V& value)
:_key(key)
, _value(value)
, _left(nullptr)
, _right(nullptr)
{}
};
template<class K, class V>
struct BSTree
{
typedef BSTreeNode<K, V> Node;
public:
BSTree()
:_root(nullptr)
{}
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (key > cur->_key)
cur = cur->_right;
else if (key < cur->_key)
cur = cur->_left;
else
return cur;
}
return nullptr;
}
bool Insert(const K& key, const V& value)
{
if (_root == nullptr)
{
_root = new Node(key, value);
return true;
}
else
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)//寻找插入的位置
{
if (key > cur->_key)//key比cur大,说明要插入到右子树
{
parent = cur;
cur = cur->_right;
}
else if (key < cur->_key)//key比cur小,说明要插入到左子树
{
parent = cur;
cur = cur->_left;
}
else//如果要key已经存在,则不需要再插入,返回false
{
return false;
}
}
if (key > parent->_key)//key比parent大,插在右边
parent->_right = new Node(key, value);
else//key比parent小,插在左边
parent->_left = new Node(key, value);
}
return true;
}
bool Erase(const K& key)
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (key > cur->_key)//key比cur大,在右边
{
parent = cur;
cur = cur->_right;
}
else if (key < cur->_key)//key比cur小,在左边
{
parent = cur;
cur = cur->_left;
}
else//找到了,然后进行删除
{
if (cur->_left == nullptr)
{
if (parent == nullptr)//处理cur为根节点,parent为nullptr的情况
{
_root = cur->_right;
}
else
{
if (parent->_right == cur)//cur是parent的右子树
parent->_right = cur->_right;//parent的右连接cur的右
else//cur是parent的左子树
parent->_left = cur->_right;//parent的左连接cur的右
}
delete cur;
}
else if (cur->_right == nullptr)
{
if (parent == nullptr)//处理cur为根节点,parent为nullptr的情况
{
_root = cur->_left;
}
else
{
if (parent->_right == cur)//cur是parent的右子树
parent->_right = cur->_left;//parent的右连接cur的左
else//cur是parent的左子树
parent->_left = cur->_left;//parent的左连接cur的左
}
delete cur;
}
else//cur的左右都不为nullptr,左子树最右节点或者右子树的最左结点
{
Node* min = cur->_right;
Node* minparent = cur;//也能处理min已经没有左子树,已经是最小结点的情况
while (min->_left)//找最小
{
minparent = min;
min = min->_left;
}
cur->_key = min->_key;//将min中的_key赋值给cur
cur->_value = min->_value;
if (minparent->_left == min)
minparent->_left = min->_right;//处理minparent的左结点是min的情况
else
minparent->_right = min->_right;//处理minparent的右结点是min的情况
delete min;
}
return true;
}
}
return false;//,如果走到这里,表示没有这个值
}
void InOrder()
{
_InOrede(_root);
cout << endl;
}
private:
void _InOrede(Node* root)
{
if (root == nullptr)
return;
_InOrede(root->_left);//递归左
cout << root->_key << ":" << root->_value << endl;
_InOrede(root->_right);//递归右
}
Node* _root;
};
void test2()
{
KV::BSTree<string, string> dict;
dict.Insert("hello", "你好");
dict.Insert("left", "左边");
dict.Insert("right", "右边");
dict.InOrder();
}
int main()
{
test2();
return 0;
}
运行代码:
再举个栗子:
对于不存在的水果,就插入,存在了就统计次数
void test3()
{
KV::BSTree<string, int> countTree;
string arr[] = { "苹果", "李子", "苹果", "香蕉", "西瓜", "香蕉", "桃子", "桃子", "桃子", "西瓜" };
for (auto& str : arr)
{
auto ret = countTree.Find(str);
if (ret != nullptr)
ret->_value++;
else
countTree.Insert(str, 1);
}
countTree.InOrder();
}
int main()
{
test3();
return 0;
}