二叉搜索树

概念

二叉搜索树又称为二叉排序树，是一种二叉树数据结构。
它可以是一棵空树，或者具有以下性质的二叉树：

1. 如果左子树不为空，左子树上所有节点的值都小于根节点的值。
2. 如果右子树不为空，右子树上所有节点的值都大于根节点的值。
3. 任意节点的左右子树也分别为二叉搜索树。

这棵树的中序遍历的结果是：1->5->6->7->10->15->18->20
由此可得，二叉搜索树的中序遍历是有序的

验证二叉树是否是二叉搜索树

检查每个节点的值是否在范围之内

bool isValidBST(TreeNode* root) {
	return isValidBST(root, -LONG_MAX, LONG_MAX);

}
bool isValidBST(TreeNode* root, long long left, long long right)
{
	if (root == nullptr)
	{
		return true;
	}
	if (root->val <= left || root->val >= right)
	{
		return false;
	}
	return isValidBST(root->left, left, root->val) &&
		isValidBST(root->right, root->val, right);
}

二叉搜索树的查找

在二叉搜索树查找某个target，返回target对应的节点，不存在返回nullptr
对于每个不为空的节点，会出现以下三种情况：

1. 如果target等于当前节点节点的值，则返回节点;
2. 如果target小于当前节点的值，则在左子树中搜索;
3. 如果target大于当前节点的值，则在右子树中搜索。

//递归法
TreeNode* searchBST(TreeNode* root, int val) {
	if (root == nullptr || root->val == val)
	{
		return root;
	}
	if (root->val < val)
	{
		return searchBST(root->right, val);
	}
	return searchBST(root->left, val);
}
//迭代法
TreeNode* searchBST(TreeNode* root, int val) {
        while (root) {
            if (val == root->val) {
                return root;
            }
            root = val < root->val ? root->left : root->right;
        }
        return nullptr;
    }

二叉搜索树节点的添加

要将某个值target插入到二叉搜索树中，先要查找target在二叉搜索树的位置：
target小于当前节点的值，则查询左子树，左子树为空，则在此插入
target大于当前节点的值，则查询右子树，右子树为空，则在此插入

TreeNode* insertIntoBST(TreeNode* root, int val) {
	if (root == nullptr)
	{
		root = new TreeNode(val);
		return root;
	}
	if (root->val < val) {
		root->right = insertIntoBST(root->right, val);
	}
	else {
		root->left = insertIntoBST(root->left, val);
	}
	return root;
}

二叉搜索树节点的删除

对于删除操作，仍然先要查找到要删除的target对应的节点的位置
找到节点后，可分为以下三种情况：
1、目标节点无左右子节点，直接删除即可

2、目标节点存在一个子节点，将目标节点的父节点的指针指向目标节点的子节点

3、目标节点存在两个子节点，则查找中序遍历中的目标节点的前驱或后继节点对应的元素来覆盖目标节点的值，在删除前驱节点或者后序节点即可
比如：要删除节点20，则18为前驱节点，23为后继节点，采用18的值来覆盖节点20的值，在删除左子树的节点18，将双子节点的情况转换为无子节点或只有一个子节点的情况。

TreeNode* deleteNode(TreeNode* root, int key) {
	if (root == nullptr)
	{
		return root;
	}
	if (key > root->val)
	{
		root->right = deleteNode(root->right, key);
	}
	else if (key < root->val)
	{
		root->left = deleteNode(root->left, key);
	}
	else {
		if (root->left == nullptr && root->right == nullptr)
		{
			delete root;
			return nullptr;
		}
		else if (root->left == nullptr || root->right == nullptr)
		{
			TreeNode* tmp = root;
			root = root->left == nullptr ? root->right : root->left;
			delete tmp;
		}
		else {
			int m = findPre(root->left);
			root->val = m;
			root->left = deleteNode(root->left, m);
		}
	}
	return root;
}
//找前驱节点
int findPre(TreeNode* root)
{
	int res = 0;
	while (root != nullptr)
	{
		res = root->val;
		root = root->right;
	}
	return res;
}
//找后驱节点
int findsuff(TreeNode* root)
{
	int res=0;
	while (root!= nullptr)
	{
		res=root->val;
		root = root->left;
	}
	return res;
}