1.二叉搜索树
二叉搜索树概念
二叉搜索树又称二叉排序树(Binary Search Tree, BST)，它或者是一棵空树，是具有以下性质的二叉树:
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树
BST特性，中序遍历都是有序了，上图中序遍历：15 30 33 41 50
2.二叉搜索树操作
1. 二叉搜索树的查找
a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b、最多查找高度次，走到到空，还没找到，这个值不存在。
2. 二叉搜索树的插入
插入的具体过程如下：
a. 树为空，则直接新增节点，赋值给root指针
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点
插入值为9的节点（前提，假设BST中的节点的值域唯一）
确认值为9的节点是否存在
存在：不插入，直接返回
不存在，进行2’
插入节点
构造一个新节点
与parent中的值域比较
小于parent中的值域，插入parent的左侧
大于parent中的值域，插入parent的右侧
3.删除节点
删除节点的各种情况：
只有右孩子（包含叶子节点）
只有左孩子
左右均存在
根据逻辑规则编写代码，并测试
#pragma once
template<class T>
struct BSTNode
{
BSTNode<T>* _left;
BSTNode<T>* _right;
T _data;
BSTNode(const T& data = T())
: _left(nullptr)
, _right(nullptr)
, _data(data)
{}
};
template<class T>
class BSTree
{
typedef BSTNode<T> Node;
public:
BSTree()
: _root(nullptr)
{}
~BSTree()
{
_DestroyBSTree(_root);
}
bool Insert(const T& data)
{
// 空树，直接插入(根节点)
if (nullptr == _root)
{
_root = new Node(data);
return true;
}
// 非空
// 1. 借助cur在BSTree中查找值为data的元素是否存在
// 注意：需要保存cur的parent
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
parent = cur;
if (data == cur->_data)
return false;
else if (data < cur->_data)
cur = cur->_left;
else
cur = cur->_right;
}
// 2. 插入新节点
cur = new Node(data);
if (data < parent->_data)
parent->_left = cur;
else
parent->_right = cur;
return true;
}
Node* Find(const T& data)
{
Node* cur = _root;
while (cur)
{
if (data == cur->_data)
return cur;
else if (data < cur->_data)
cur = cur->_left;
else
cur = cur->_right;
}
return nullptr;
}
void InOrder()
{
cout << "中序遍历:";
_InOrder(_root);
cout << endl;
}
bool Erase(const T& data)
{
// 空树：直接返回
if (nullptr == _root)
{
return false;
}
// 非空：
// 1. 找值为data的节点
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (data == cur->_data)
break;
else if (data < cur->_data)
{
parent = cur;
cur = cur->_left;
}
else
{
parent = cur;
cur = cur->_right;
}
}
// 确认是否找到？
if (nullptr == cur)
return false;
// 2. 删除该节点
// 分情况：
// 1. 只有右孩子 &&叶子节点
// 2. 只有左孩子
// 3. 左右孩子均存在
Node* del = cur;
if (nullptr == cur->_left)
{
// 情况一：只有右孩子 &&叶子节点
if (nullptr == parent)
{
// cur现在就是根节点
_root = cur->_right;
}
else
{
// cur一定不是根节点,说明cur的双亲一定存在
// parent一定不为空
if (cur == parent->_left)
{
parent->_left = cur->_right;
}
else
{
parent->_right = cur->_right;
}
}
}
else if (nullptr == cur->_right)
{
// 情况二：只有左孩子
if (nullptr == parent)
{
// cur现在就是根节点
_root = cur->_left;
}
else
{
// cur一定不是根节点,说明cur的双亲一定存在
// parent一定不为空
if (cur == parent->_left)
{
parent->_left = cur->_left;
}
else
{
parent->_right = cur->_left;
}
}
}
else
{
// 情况三：左右孩子均存在
// cur不能直接删除，需要在其子树中找一个替代节点
// 将情况三变为情况一或者情况二
// 选择在右子树中找替代节点
del = cur->_right;
parent = cur;
// 1. 找cur右子树中最小(左侧)的节点
while (del->_left)
{
parent = del;
del = del->_left;
}
// 2. 使用del中的值域替换cur中的值域
cur->_data = del->_data;
// 3. 删除del,注意：del可能是其双亲的左孩子 || 可能是其双亲的右孩子
if (del == parent->_left)
parent->_left = del->_right;
else
parent->_right = del->_right;
}
delete del;
return true;
}
private:
void _InOrder(Node* root)
{
if (root)
{
_InOrder(root->_left);
cout << root->_data << " ";
_InOrder(root->_right);
}
}
void _DestroyBSTree(Node*& root)
{
if (root)
{
_DestroyBSTree(root->_left);
_DestroyBSTree(root->_right);
delete root;
root = nullptr;
}
}
private:
BSTNode<T>* _root;
};
void TestBSTree()
{
BSTree<int> t;
int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
for (auto e : a)
{
t.Insert(e);
}
t.InOrder();
if (!t.Find(9))
{
t.Insert(9);
}
t.InOrder();
//t.Erase(4);
//t.InOrder();
//t.Erase(6);
//t.InOrder();
t.Erase(8);
t.InOrder();
}#include<iostream>
using namespace std;
#include"BinarySearchTree.hpp"
int main()
{
TestBSTree();
return 0;
}
3. 二叉搜索树的应用
1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
2. KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对
4. 二叉搜索树的性能分析
插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：$log_2 N$
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：$\frac{N}{2}$
问题：如果退化成单支树，二叉搜索树的性能就失去了。
解决办法：AVL树和红黑树
一些练习题：LetCode
1. 二叉树创建字符串。
2. 二叉树的分层遍历1。
3. 二叉树的分层遍历2。
4. 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先 。
5. 二叉树搜索树转换成排序双向链表。
6. 根据一棵树的前序遍历与中序遍历构造二叉树。
7. 根据一棵树的中序遍历与后序遍历构造二叉树。
8. 二叉树的前序遍历，非递归迭代实现 。
9. 二叉树中序遍历 ，非递归迭代实现。
10. 二叉树的后序遍历 ，非递归迭代实现。