二叉搜索樹
基本概念
二叉搜索樹又稱二叉排序樹，它或者是一棵空樹，或者是具有以下性質的二叉樹:
- 若它的左子樹不空，則左子樹上所有節點的值均小於它的根節點的值；
- 若它的右子樹不空，則右子樹上所有節點的值均大於它的根節點的值；
- 它的左右子樹也分別爲二叉排序樹。
如下圖所示
二叉搜索樹的查找
- 若根節點 = 要查找的節點 返回true
- 若根節點 < 要查找的節點 ，在右子樹種查找
- 若根節點 > 要查找的節點 ，在左子樹中查找
重複上述過程，直至查找成功返回找到的結點，否則返回false。
二叉搜索樹的插入
- 若二叉搜索樹爲空，直接插入
- 若二叉搜索樹不爲空，按二叉搜索樹性質查找插入位置，插入新節點
二叉搜索樹的刪除
首先查找元素是否在二叉搜索樹中，如果不存在，則返回, 否則要刪除的結點可能分下面四種情況：
a. 要刪除的結點無孩子結點
b. 要刪除的結點只有左孩子結點
c. 要刪除的結點只有右孩子結點
d. 要刪除的結點有左、右孩子結點
看起來有待刪除節點有4中情況，實際情況a可以與情況b或者c合併起來，因此真正的刪除過程如下：
情況b：刪除該結點且使被刪除節點的雙親結點指向被刪除節點的左孩子結點
情況c：刪除該結點且使被刪除節點的雙親結點指向被刪除結點的右孩子結點
情況d：在它的右子樹中尋找中序下的第一個結點(關鍵碼最小)，用它的值填補到被刪除節點中，再來處理該結點的刪除問題
二叉搜索樹的實現
//實現簡易版的二叉搜索樹
// 插入 查找 刪除
#include <iostream>
using namespace std;
template <class k,class v>
class BSTreeNode {
public:
BSTreeNode(const pair<k, v> kv)
:_kv(kv)
, left(nullptr)
, right(nullptr)
{}
public:
pair<k, v> _kv;
BSTreeNode<k, v>* left;
BSTreeNode<k, v>* right;
};
template<class k,class v>
class BSTree {
public:
typedef BSTreeNode<k,v> Node;
BSTree()
:_root(nullptr)
{}
//插入
bool Insert(const pair<k, v> kv) {
if (_root == nullptr) {
_root = new Node(kv);
return true;
}
Node* parent = nullptr;
Node* cur = _root;
while (cur) {
if (cur->_kv.first < kv.first) {
parent = cur;
cur = cur->right;
}
else if (cur->_kv.first > kv.first) {
parent = cur;
cur = cur->left;
}
else {
return false;
}
}
cur = new Node(kv);
if (parent->_kv.first < kv.first) {
parent->right = cur;
}
else {
parent->left = cur;
}
return true;
}
//查找
Node* Find(const k& key) {
Node* cur = _root;
while (cur) {
if (cur->_kv.first < key) {
cur = cur->left;
}
else if(cur->_kv.first > key){
cur = cur->right;
}
else{
return cur;
}
}
return nullptr;
}
//刪除
bool Remove(const k& key) {
Node* parent = nullptr;
Node* cur = _root;
while (cur) {
if (cur->_kv.first < key) {
parent = cur;
cur = cur->right;
}
else if(cur->_kv.first > key){
parent = cur;
cur = cur->left;
}
else { //找到
//沒有孩子，只有一個孩子，兩個孩子都有
Node* del = cur;
//只有右孩子
if (cur->left == nullptr) {
if (parent == nullptr) {
_root = cur->right;
}
else{
if (parent->left == cur) {
parent->left = cur->right;
}
else {
parent->right = cur->right;
}
}
}
//只有左孩子
else if (cur->right == nullptr) {
if (parent->left == cur) {
parent->left = cur->left;
}
else {
parent->right = cur->left;
}
}
//左右孩子都有
else {
Node* reparent = cur;
Node* replace = cur->right;
while (replace->left) { //在右子樹中找最左節點
reparent = replace;
replace = replace->left;
}
cur->_kv = replace->_kv; //替換節點值
del = replace;
if (reparent->left == replace) {
reparent->left = replace->right;
}
else {
reparent->right = replace->right;
}
}
delete del;
return true;
}
}
return false;
}
//中序遍歷
void InOrder()
{
_InOrder(_root);
cout << endl;
}
void _InOrder(Node* root)
{
if (root == nullptr)
return;
_InOrder(root->left);
cout << root->_kv.first << " ";
_InOrder(root->right);
}
private:
Node* _root;
};
void TestBSTree1()
{
BSTree<int, int> tree;
tree.Insert(make_pair(1, 1));
tree.Insert(make_pair(3, 1));
tree.Insert(make_pair(4, 1));
tree.Insert(make_pair(6, 1));
tree.Insert(make_pair(1, 1));
tree.Insert(make_pair(2, 1));
tree.InOrder();
tree.Remove(1);
tree.Remove(3);
tree.Remove(2);
tree.Remove(6);
tree.Remove(4);
tree.Remove(1);
tree.Remove(10);
tree.InOrder();
}
int main(void) {
TestBSTree1();
system("pause");
return 0;
}
二叉搜索樹性能分析
我們可以看出來其實它就是一個二分查找，所以BST的查找和插入刪除關鍵字的速度較於一般的數組鏈表都比較快。這就是BST產生的原因。但是，創建好BST後，插入數據的隨機性，所以會出現比較極端的BST。
最優情況下，二叉搜索樹爲完全二叉樹，其時間複雜度爲：log(n)
最差情況下，二叉搜索樹退化爲單支樹，其時間複雜度爲：O(n)
第一張圖的就是我們理想的情況，可是卻可能出現第二張圖的情況，第一張圖操作的時間複雜度爲log(n),而第二張圖則爲O(n)，所以這也是BST沒有廣泛使用的原因。