目录
二叉搜索树也叫二叉排序树
之所以叫它搜索树是因为它本身搜索的速度快
二叉搜索树的性质
若它的左子树不为空，则左子树上的所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上的所有节点的值都大于根节点的值
它的左右子树也叫二叉搜索树
STL里的map/set/multimap/multiset系列容器的底层就是二叉搜索树
map/set不支持插入相同值
multimap/multiset支持插入相同值
二叉搜索树性能
由于它的性质，它具有二分查找的优势，但是没有二分查找的限制
二分查找需要在支持下标随机访问的结构中，并且要求有序
在这样的结构中的插入和删除效率就极低
如果这棵树分布的比较平均，那么它的时间复杂度可以达到O(logN)
但如果是这样呢
那么它的时间复杂度最坏会达到O(N)
所以时间复杂度为O(N)
二叉搜索树结构
template<class K>
struct BSTNode
{
K _key;
BSTNode<K>* _left;
BSTNode<K>* _right;
BSTNode(const K& key)
:_key(key)
, _left(nullptr)
, _right(nullptr)
{}
};
template<class K>
class BSTree
{
using Node = BSTNode<K>;
public:
private:
Node* _root = nullptr;
};这里需要一个Node结构体作为一个节点，_root指向当前节点
二叉搜索树的插入
代码看着长，但是思路比较简单
bool Insert(const K& key)
{
if (_root == nullptr)
{
_root = new Node(key);
return true;
}
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
cur = new Node(key);
if (parent->_key > key)
{
parent->_left = cur;
}
else
{
parent->_right = cur;
}
return true;
}若树为空，则直接新增节点，赋值给root指针
若树不为空，则需要先找到当前key所应该呆在该树的位置，这个位置选择的规则必须要遵守左小右大的原则
所以定义一个cur指针指向当前节点和一个parent指针指向cur的父亲节点，若当前节点的key值大于插入的key值，那么key值小，需要往左子树去，若当前节点key值小于插入的key值，则往右子树去。若相等，则插入失败（只能有一个相同的key）
找到了key值的插入位置后，只需要确定这个key值需要在parent的左还是在parent的右即可
二叉搜索树的查找
bool Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_key > key)
{
cur = cur->_left;
}
else if (cur->_key < key)
{
cur = cur->_right;
}
else
{
return true;
}
}
return false;
}二叉搜索树的查找和插入的思路一模一样，甚至比插入还简单
跟插入找位置的思路一样，若能找到值则返回true，否则返回false
二叉搜索树的删除
删除需要考虑的情况就比较多了
bool Erase(const K& key)
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < 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;
}
else if (cur->_right == nullptr) // 右为空
{
if (cur == _root)
{
_root = cur->_left;
}
else
{
// 需要父亲节点接管左子树
if (parent->_left == cur)
{
parent->_left = cur->_left;
}
else
{
parent->_right = cur->_left;
}
}
delete cur;
}
else // 都不为空，找左子树的最右节点或右子树的最左节点
{
// 找代替节点（右子树最小）
Node* replaceParent = cur;
Node* replace = cur->_right;
while (replace->_left)
{
replaceParent = replace;
replace = replace->_left;
}
cur->_key = replace->_key;
// 需要接管代替节点的右子树
if (replaceParent->_left == replace)
{
replaceParent->_left = replace->_right;
}
else
{
replaceParent->_right = replace->_right;
}
delete replace;
}
return true;
}
}
return false;
}首先和前面的插入和查找一样，先找到我们需要删除的节点
找到后，有三种情况
1. 左子树为空
2. 右子树为空
3. 都不为空
左子树为空
无论右子树是否为空
首先要判断删除节点是否为根节点，若为根节点则直接让右子树作为根
让删除节点的父亲节点指向右子树，具体是父的左还是右需要判断删除节点是在父的左还是右
当父节点接管完右子树后，就可以放心的删除掉删除节点了
右子树为空
无论左子树是否为空
首先要判断删除节点是否为根节点，若为根节点则直接让左子树作为根
让删除节点的父亲节点指向左子树，具体是父的左还是右需要判断删除节点是在父的左还是右
当父节点接管完左子树后，就可以放心的删除掉删除节点了
都不为空
我们需要找一个代替节点来代替它当前的位置
这个位置只能是左子树的最大值或者右子树的最小值，这样这个值才能替代它的位置
上面的代码找的是右子树的最小值
从右子树开始通过一个循环一直向左就可以找到那个最小值了
这时候只需要把两者的值交换即可
在删除代替节点的时候需要先把代替节点的父节点的指向处理好，之后就可以放心的删除代替节点了
二叉搜索树的key/value
逻辑和前面的代码基本一致，只需要多增加一个模板参数value，在一些细节的地方处理一下即可
template<class K, class V>
struct BSTNode
{
K _key;
V _value;
BSTNode<K, V>* _left;
BSTNode<K, V>* _right;
BSTNode(const K& key, const V& value)
:_key(key)
, _value(value)
, _left(nullptr)
, _right(nullptr)
{}
};
template<class K, class V>
class BSTree
{
using Node = BSTNode<K, V>;
public:
BSTree() = default;
BSTree(const BSTree& t)
{
_root = Copy(t._root);
}
BSTree& operator=(BSTree tmp)
{
swap(_root, tmp._root);
return *this;
}
~BSTree()
{
Destroy(_root);
_root = nullptr;
}
bool Insert(const K& key, const V& value)
{
if (_root == nullptr)
{
_root = new Node(key, value);
return true;
}
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
cur = new Node(key, value);
if (parent->_key > key)
{
parent->_left = cur;
}
else
{
parent->_right = cur;
}
return true;
}
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_key > key)
{
cur = cur->_left;
}
else if (cur->_key < key)
{
cur = cur->_right;
}
else
{
return cur;
}
}
return nullptr;
}
bool Erase(const K& key)
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < 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;
}
else if (cur->_right == nullptr) // 右为空
{
if (cur == _root)
{
_root = cur->_left;
}
else
{
// 需要父亲节点接管左子树
if (parent->_left == cur)
{
parent->_left = cur->_left;
}
else
{
parent->_right = cur->_left;
}
}
delete cur;
}
else // 都不为空，找左子树的最右节点或右子树的最左节点
{
// 找代替节点（右子树最小）
Node* replaceParent = cur;
Node* replace = cur->_right;
while (replace->_left)
{
replaceParent = replace;
replace = replace->_left;
}
cur->_key = replace->_key;
// 需要接管代替节点的右子树
if (replaceParent->_left == replace)
{
replaceParent->_left = replace->_right;
}
else
{
replaceParent->_right = replace->_right;
}
delete replace;
}
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 << " ";
_InOrder(root->_right);
}
void Destroy(Node* root)
{
if (root == nullptr)
return;
Destroy(root->_left);
Destroy(root->_right);
delete root;
}
Node* Copy(Node* root)
{
if (root == nullptr)
return nullptr;
Node* newRoot = new Node(root->_key, root->_value);
newRoot->_left = Copy(root->_left);
newRoot->_right = Copy(root->_right);
return newRoot;
}
private:
Node* _root = nullptr;
};二叉搜索树key、key/value完整代码
#pragma once
#include <iostream>
using namespace std;
namespace key
{
template<class K>
struct BSTNode
{
K _key;
BSTNode<K>* _left;
BSTNode<K>* _right;
BSTNode(const K& key)
:_key(key)
, _left(nullptr)
, _right(nullptr)
{}
};
template<class K>
class BSTree
{
using Node = BSTNode<K>;
public:
bool Insert(const K& key)
{
if (_root == nullptr)
{
_root = new Node(key);
return true;
}
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
cur = new Node(key);
if (parent->_key > key)
{
parent->_left = cur;
}
else
{
parent->_right = cur;
}
return true;
}
bool Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_key > key)
{
cur = cur->_left;
}
else if (cur->_key < key)
{
cur = cur->_right;
}
else
{
return true;
}
}
return false;
}
bool Erase(const K& key)
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < 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;
}
else if (cur->_right == nullptr) // 右为空
{
if (cur == _root)
{
_root = cur->_left;
}
else
{
// 需要父亲节点接管左子树
if (parent->_left == cur)
{
parent->_left = cur->_left;
}
else
{
parent->_right = cur->_left;
}
}
delete cur;
}
else // 都不为空，找左子树的最右节点或右子树的最左节点
{
// 找代替节点（右子树最小）
Node* replaceParent = cur;
Node* replace = cur->_right;
while (replace->_left)
{
replaceParent = replace;
replace = replace->_left;
}
cur->_key = replace->_key;
// 需要接管代替节点的右子树
if (replaceParent->_left == replace)
{
replaceParent->_left = replace->_right;
}
else
{
replaceParent->_right = replace->_right;
}
delete replace;
}
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 << " ";
_InOrder(root->_right);
}
private:
Node* _root = nullptr;
};
}
namespace key_value
{
template<class K, class V>
struct BSTNode
{
K _key;
V _value;
BSTNode<K, V>* _left;
BSTNode<K, V>* _right;
BSTNode(const K& key, const V& value)
:_key(key)
, _value(value)
, _left(nullptr)
, _right(nullptr)
{}
};
template<class K, class V>
class BSTree
{
using Node = BSTNode<K, V>;
public:
BSTree() = default;
BSTree(const BSTree& t)
{
_root = Copy(t._root);
}
BSTree& operator=(BSTree tmp)
{
swap(_root, tmp._root);
return *this;
}
~BSTree()
{
Destroy(_root);
_root = nullptr;
}
bool Insert(const K& key, const V& value)
{
if (_root == nullptr)
{
_root = new Node(key, value);
return true;
}
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
cur = new Node(key, value);
if (parent->_key > key)
{
parent->_left = cur;
}
else
{
parent->_right = cur;
}
return true;
}
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_key > key)
{
cur = cur->_left;
}
else if (cur->_key < key)
{
cur = cur->_right;
}
else
{
return cur;
}
}
return nullptr;
}
bool Erase(const K& key)
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < 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;
}
else if (cur->_right == nullptr) // 右为空
{
if (cur == _root)
{
_root = cur->_left;
}
else
{
// 需要父亲节点接管左子树
if (parent->_left == cur)
{
parent->_left = cur->_left;
}
else
{
parent->_right = cur->_left;
}
}
delete cur;
}
else // 都不为空，找左子树的最右节点或右子树的最左节点
{
// 找代替节点（右子树最小）
Node* replaceParent = cur;
Node* replace = cur->_right;
while (replace->_left)
{
replaceParent = replace;
replace = replace->_left;
}
cur->_key = replace->_key;
// 需要接管代替节点的右子树
if (replaceParent->_left == replace)
{
replaceParent->_left = replace->_right;
}
else
{
replaceParent->_right = replace->_right;
}
delete replace;
}
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 << " ";
_InOrder(root->_right);
}
void Destroy(Node* root)
{
if (root == nullptr)
return;
Destroy(root->_left);
Destroy(root->_right);
delete root;
}
Node* Copy(Node* root)
{
if (root == nullptr)
return nullptr;
Node* newRoot = new Node(root->_key, root->_value);
newRoot->_left = Copy(root->_left);
newRoot->_right = Copy(root->_right);
return newRoot;
}
private:
Node* _root = nullptr;
};
}完
扫一扫
312
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
