前言：
终于放寒假了，在家休息几天然后查了下考研学校后，打算开始写总结了。原因很简单，刷过的好多题都忘了，打算二刷顺便写下总结。引用名言：“学而不思则罔，思而不学则殆。”所以在做题的同时，我们需要更多的思考，这样才能把知识完全学懂，今日总结的主题是《二叉搜索树》。
二叉搜索树的定义及性质：
二叉搜索树（英语：Binary Search Tree），也称为二叉查找树、有序二叉树（ordered binary tree）或排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树：
- 1）每个节点中的值必须大于（或等于）存储在其左侧子树中的任何值。
- 2）每个节点中的值必须小于（或等于）存储在其右子树中的任何值。
- 3）任意节点的左右子树也是二叉搜索树。
二叉搜索树与二叉树的关系：
二叉搜索树也是一颗二叉树，只不过是需要满足它三点性质的二叉树。对于二叉搜索树，我们也可以利用层序遍历、前序遍历，中序遍历、后序遍历来遍历它，但是值得注意的是二叉搜索树的中序遍历（左根右）遍历出来的结果是一个有序数组，也可将二叉搜索树的所有节点值映射到一条水平直线上，得到结果也将是一个有序数组。
二叉搜索树的搜索操作：
1）如果目标值等于节点的值，则返回节点;
2）如果目标值小于节点的值，则继续在左子树中搜索;
3）如果目标值大于节点的值，则继续在右子树中搜索。
代码如下：
/*搜索节点值*/
TreeNode* searchBST(TreeNode* root, int val) {
if(root==nullptr)return root;
//1、找到目标值，返回该节点
if(root->val==val)return root;
//2、目标值小于该节点的值，则在左子树中寻找
else if(root->val>val)return searchBST(root->left,val);
//3、目标值大于该节点的值，则在右子树中寻找
else return searchBST(root->right,val);
}
二叉树的插入操作：
由于二叉树的插入操作有多种，比如：有改变原树结构的插入；也有根据搜索方式选择合适的叶子节点进行插入新节点。在这里我们主要使用后一种方法进行插入。
1）根据节点值与目标节点值的关系，搜索左子树或右子树；
2）重复步骤 1 直到到达外部节点（空节点）；
3）根据节点的值与目标节点的值的关系，将新节点添加为其左侧或右侧的子节点。
代码如下：
//递归版：插入节点值
TreeNode* insertIntoBST_1(TreeNode* root, int val) {
if(root==nullptr)return new TreeNode(val);
else
{
//val的值小于根节点的值，要插在左边，递归直到左边的叶子节点时，将val的节点添加到最左边叶子节点的left节点
if(val<root->val)root->left=insertIntoBST_1(root->left,val);
//val的值大于根节点的值，要插在右边，递归直到右边的叶子节点时，将val的节点添加到最右边叶子节点的right节点
if(val>root->val)root->right=insertIntoBST_1(root->right,val);
}
return root;
}
二叉树的删除操作：
删除要比我们前面提到过的两种操作复杂许多。有许多不同的删除节点的方法，我们只讨论一种使整体操作变化最小的方法。我们的方案是用一个合适的子节点来替换要删除的目标节点。根据其子节点的个数，我们需考虑以下三种情况：
- 1）如果目标节点没有子节点，我们可以直接移除该目标节点。
- 2）如果目标节只有一个子节点，我们可以用其子节点作为替换。
- 3）如果目标节点有两个子节点，我们需要用其中序后继节点或者前驱节点来替换，再删除该目标节点。
代码如下：
//第一种方法删除节点：我们将删除节点的右子树连接在其左子树的最右节点上面，然后返回左子树
TreeNode* deleteNode_1(TreeNode* root, int key) {
if(root==nullptr)return nullptr;
if (root->val==key)//找到需要删除的节点
{
if (root->left)
{//遍历需要删除节点的左子树，找到该左子树的最右边节点，也就是整个左子树中的最大值，然后将删除的节点的右子树连接到最右边节点上，返回左子树
//这句话的意思是说：我们将需要删除节点的右子树连接在其左子树的最右节点上面，因为右子树的最小值根节点也会大于左子树的最大值（最右节点）
TreeNode* node = root->left;
while (node->right) node = node->right;
node->right = root->right;
return root->left;
}
//左子树为空，直接将右子树节点替换到删除节点上
return root->right;
}
if (root->val>key)root->left = deleteNode_1(root->left, key);
else root->right = deleteNode_1(root->right, key);
return root;
}
//第二种删除节点的方法：我们将删除节点的左子树连接在其右子树的最左节点上
TreeNode* deleteNode_2(TreeNode* root,int key)
{
if(root==nullptr)return nullptr;
if(root->val==key)
{
if(root->right)
{//遍历删除节点的右子树，找到该右子树的最左边节点，也就是整个右子树中的最小值，然后将删除节点的左子树连接到最左边节点上，返回右子树
//因为删除节点左子树的所有节点都小于删除节点，而删除节点的右子树的所有节点都大于删除节点，所以右子树中的最小节点值也会大于左子树中的最大节点值
TreeNode* node=root->right;
while(node->left)node=node->left;
node->left=root->left;
return root->right;
}
return root->left;
}
if(root->val>key)root->left = deleteNode_2(root->left, key);
else root->right = deleteNode_2(root->right, key);
return root;
}
二叉搜索树的模板：
class BST
{
private:
/*节点*/
struct TreeNode
{
int val;
TreeNode *left, *right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
TreeNode* root;
private:
//递归版：搜索节点值
TreeNode* searchBST_1(TreeNode* root, int val) {
if(root==nullptr)return root;
if(root->val==val)return root;
else if(root->val>val)return searchBST_1(root->left,val);
else return searchBST_1(root->right,val);
}
//迭代版：搜索节点值
TreeNode* searchBST_2(TreeNode* root,int val){
while(root){
if(root->val==val)return root;
else if(val<root->val)root=root->left;
else root=root->right;
}
return nullptr;
}
//递归版：插入节点值
TreeNode* insertIntoBST_1(TreeNode* root, int val) {
if(root==nullptr)return new TreeNode(val);
else
{
//val的值小于根节点的值，要插在左边，递归直到左边的叶子节点时，将val的节点添加到最左边叶子节点的left节点
if(val<root->val)root->left=insertIntoBST_1(root->left,val);
//val的值大于根节点的值，要插在右边，递归直到右边的叶子节点时，将val的节点添加到最右边叶子节点的right节点
if(val>root->val)root->right=insertIntoBST_1(root->right,val);
}
return root;
}
//迭代版：插入节点值
TreeNode* insertIntoBST_2(TreeNode* root,int val){
if(!root)return new TreeNode(val);
TreeNode* p=root;
while(p){
if(val<p->val){//在左子树中寻找叶子节点进行插入
if(!p->left){//找到叶子节点，插入到叶子节点后面
p->left=new TreeNode(val);
return root;
}
p=p->left;
}
else{//在右子树中寻找叶子节点进行插入
if(!p->right){//找到叶子节点，插入到叶子节点后面
p->right=new TreeNode(val);
return root;
}
p=p->right;
}
}
return root;
}
//第一种方法删除节点：我们将删除节点的右子树连接在其左子树的最右节点上面，然后返回左子树
TreeNode *deleteNode_1(TreeNode* root, int key)
{
if (root == nullptr)
return nullptr;
if (root->val == key) //找到需要删除的节点
{
if (root->left)
{ //遍历需要删除节点的左子树，找到该左子树的最右边节点，也就是整个左子树中的最大值，然后将删除的节点的右子树连接到最右边节点上，返回左子树
//这句话的意思是说：我们将需要删除节点的右子树连接在其左子树的最右节点上面，因为右子树的最小值根节点也会大于左子树的最大值（最右节点）
TreeNode *node = root->left;
while (node->right)
node = node->right;
node->right = root->right;
return root->left;
}
//左子树为空，直接将右子树节点替换到删除节点上
return root->right;
}
if (root->val > key)
root->left = deleteNode_1(root->left, key);
else
root->right = deleteNode_1(root->right, key);
return root;
}
//第二种删除节点的方法：我们将删除节点的左子树连接在其右子树的最左节点上
TreeNode *deleteNode_2(TreeNode* root, int key)
{
if (root == nullptr)
return nullptr;
if (root->val == key)
{
if (root->right)
{ //遍历删除节点的右子树，找到该右子树的最左边节点，也就是整个右子树中的最小值，然后将删除节点的左子树连接到最左边节点上，返回右子树
//因为删除节点左子树的所有节点都小于删除节点，而删除节点的右子树的所有节点都大于删除节点，所以右子树中的最小节点值也会大于左子树中的最大节点值
TreeNode *node = root->right;
while (node->left)
node = node->left;
node->left = root->left;
return root->right;
}
return root->left;
}
if (root->val > key)
root->left = deleteNode_2(root->left, key);
else
root->right = deleteNode_2(root->right, key);
return root;
}
//中序遍历：得到排序数组
vector<int> inorderTraversal(TreeNode* root) {
if(nullptr==root) return {};
vector<int> result;
stack<TreeNode*> recond;
while(!recond.empty()||root!=nullptr)
{
if(root!=nullptr)//进栈顺序为根左...根左，出栈顺序为左根...左根
{
recond.push(root);
root=root->left;
}
else//直至上一结点的左结点为nullptr时，将上一结点的val打印，并添加其右子树
{
TreeNode* top=recond.top();recond.pop();
result.push_back(top->val);
root=top->right;
}
}
return result;
}
public:
BST():root(nullptr){}
TreeNode* searchBST_1(int val){
return searchBST_1(root,val);
}
TreeNode* searchBST_2(int val){
return searchBST_2(root,val);
}
TreeNode* insertIntoBST_1(int val){
root=insertIntoBST_1(root,val);
return root;
}
TreeNode* insertIntoBST_2(int val){
root=insertIntoBST_2(root,val);
return root;
}
TreeNode* deleteNode_1(int key){
root=deleteNode_1(root,key);
return root;
}
TreeNode* deleteNode_2(int key){
root=deleteNode_2(root,key);
return root;
}
vector<int> inorderTraversal(){
return inorderTraversal(root);
}
};
二叉搜索树的时间复杂度：
二叉查找树相比于其他数据结构的优势在于查找、插入的时间复杂度较低，为O(log n)。二叉查找树是基础性数据结构，用于构建更为抽象的数据结构，如集合、多重集、关联数组等。
二叉查找树的查找过程和次优二叉树类似，通常采取二叉链表作为二叉查找树的存储结构。中序遍历二叉查找树可得到一个关键字的有序序列，一个无序序列可以透过建构一棵二叉查找树变成一个有序序列，建构树的过程即为对无序序列进行查找的过程。每次插入的新的结点都是二叉查找树上新的叶子结点，在进行插入操作时，不必移动其它结点，只需改动某个结点的指针，由空变为非空即可。搜索、插入、删除的复杂度等于树高，期望O(log n)，最坏O(n)（数列有序，树退化成线性表）。
虽然二叉查找树的最坏效率是O(n)，但它支持动态查询，且有很多改进版的二叉查找树可以使树高为O(log n)，从而将最坏效率降至O(log n)。
二叉搜索树相关题目：
95. 不同的二叉搜索树 II：主要利用二叉搜索树的性质进行分治法，以根节点i为分界点，分别求出左子树的节点集合[1,i-1]，右子树的节点集合[i+1,n]，然后再两两组合左右子树的节点，形成最终结果。分治法的最小子问题为区间内没有元素时，最小子问题得解，左右子树节点集合也得解了。
96. 不同的二叉搜索树：这道题其实和二叉搜索树没有多大关系，主要考察数学公式及推导，所以大家不会做很正常，下次碰到知道怎么做就行了。重点记一下卡特兰数的第一个公式就好。
98. 验证二叉搜索树：用类似中序遍历（左根右）的方式来验证是否为二叉搜索树，若左子树的值大于等于根节点的值，则返回false；若根结点的值大于等于右子树的值，则返回false。
108. 将有序数组转换为二叉搜索树：由于有序数组的中位数为二叉搜索树的根节点，所以我们需要根据有序数组的中位数来划分左右子树，然后利用递归将根节点连接左右子树即可。
173. 二叉搜索树迭代器：仅仅将中序遍历最小值之前的节点压入栈中，当next时我们将栈顶元素取出即为最小值返回，当然在此之前需要将下一个最小值找到，并将路径上的所有节点压入栈中以供使用，查看是否迭代到头只需判断栈是否为空即可。
230. 二叉搜索树中第K小的元素：直接利用中序遍历，返回第k个节点值即可，注意要用一个计数器count，计算是否到第k个节点。
235. 二叉搜索树的最近公共祖先：充分利用二叉搜索数的性质，若pq都在左子树中，我们需要在左子树寻找最近公共祖先；若pq都在右子树中，我们需要在右子树中寻找最近公共祖先；若pq分别在左右子树中，那么此时的根节点就是就是最近公共祖先。
530. 二叉搜索树的最小绝对差：利用中序遍历将二叉搜索树转换为一个升序数组，然后遍历这个数组，计算差的绝对值。
501. 二叉搜索树中的众数：二叉搜索树的中序遍历是一个升序序列，逐个比对当前结点(root)值与前驱结点（pre)值。更新当前节点值出现次数(curTimes，初始化为1)及最大出现次数(maxTimes)，更新规则：若curTimes=maxTimes,将root->val添加到结果向量(res)中；若curTimes>maxTimes,清空res,将root->val添加到res,并更新maxTimes为curTimes。
1305. 两棵二叉搜索树中的所有元素：直接利用树的前序遍历将两课树的所有节点值存放在一个数组中，然后将数组排序输出就好了。
