树的结构体定义

struct TreeNode
{
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

插入

因为二叉搜索树不允许存在相等的值，所以插入有可能失败

非递归版

bool BSTInsert(TreeNode* &root,int val)
{
	TreeNode *node = new TreeNode(val);
	if (root == NULL)
	{
		root = node;
		return true;
	}	
	TreeNode *x = root,*y;
	while (x != NULL)
	{
		y = x;
		if (val == x->val)
			return false;
		if (val < x->val)
			x = x->left;
		else
			x = x->right;
	}
	
	if (val < y->val)
		y->left=node;
	else
		y->right=node;
	return true;
}

注意，因为root可能为空，此时需要返回new node，因此传入的参数要用引用的形式TreeNode* &root

递归版

bool BSTInsert2(TreeNode* &root, int val)
{
	TreeNode *node = new TreeNode(val);
	if (root == NULL)
	{
		root = node;
		return true;
	}

	if (val == root->val)
		return false;
	if (val < root->val)
		return BSTInsert2(root->left,val);
	return BSTInsert2(root->right, val);
}

创建

创建调用了插入的函数

void BSTCreate(TreeNode* &root,vector<int> &a)
{
	for (int val : a)
		BSTInsert2(root, val);
}

如何验证创建的结果对不对？

使用中序遍历必定是严格递增的

void helper(vector<int> &res, TreeNode* root)
{
	if (root == NULL)
		return;
	helper(res, root->left);
	res.push_back(root->val);
	helper(res, root->right);
}
vector<int> InOrderTraverse(TreeNode* root)
{
	vector<int> res;
	helper(res, root);
	return res;
}

查找

非递归版

bool BSTSearch(TreeNode* root, int val)
{
	while (root != NULL&&root->val != val)
	{
		if (val < root->val)
			root = root->left;
		else
			root = root->right;
	}
	return root != NULL;
}

递归版

bool BSTSearch2(TreeNode* root, int val)
{
	if(root == NULL)
		return false;
	if (root->val == val)
		return true;
	if (val < root->val)
		return BSTSearch2(root->left, val);
	return BSTSearch2(root->right, val);
}

删除

根据删除的结点分为三种情况

1 删除结点为叶子，直接删除即可

2 删除结点仅有一个子树，直接用其子树替代即可

3 删除结点两个子树都不为空，则可以删除该结点，然后用其直接前驱或直接后继(中序遍历)替换

用直接前驱的思路是找到其左子树的右结点，直到右侧尽头

void deleteHelper(TreeNode* node)
{
	if (node->left == NULL)
		node = node->right;
	else if (node->right == NULL)
		node = node->left;
	else
	{
		TreeNode *q=node,*l = node->left;
		while (l->right != NULL)
		{
			q = l;
			l = l->right;
		}
		node->val = l->val;
		if (q == node)
			q->left = l->left;
		else
			q->right = l->left;
	}
}
bool BSTDelete(TreeNode* root, int val)
{
	if (root == NULL)
		return false;
	if (root->val > val)
		return BSTDelete(root->left, val);
	if (root->val < val)
		return BSTDelete(root->right, val);
       deleteHelper(root);
	return true;
}