二叉搜索树BST

在二叉搜索树b中查找x的过程为：

1.若b是空树，则搜索失败，否则：

2.若x等于b的根结点的数据域之值，则查找成功；否则

3.若x小于b的根结点的数据域之值，则搜索左子树：否则

4.查找右子树

// 指针parent指向pRoot的父节点，其初始调用值为NULL
// 若查找成功，指针pTarget指向目标节点，函数返回true
// 否则指针pTarget指向查找路径上访问的最后一个节点，函数返回false
// pTarget初始值为NULL，由于函数调用过程中需要修改其指针值，所以参数传递双层指针
bool searchBST(BinaryTreeNode* pRoot, int key, BinaryTreeNode* parent, BinaryTreeNode** pTarget)
{
	if(pRoot == NULL)
	{
		*pTarget = parent;
		return false;
	}

	if(pRoot->value == key)
	{
		*pTarget = pRoot;
		return true;
	}
	else if(pRoot->value > key)
		return searchBST(pRoot->left, key, pRoot, pTarget);
	else
		return searchBST(pRoot->right, key, pRoot, pTarget);
}

向一个二叉搜索树b中插入一个节点s的算法，过程为：

1.若b是空树，则将s所指节点作为根节点插入，否则：

2.若s->value等于b的根节点的数据域之值，则返回，否则：

3.若s->value小于b的根节点的数据域之值，则把s所指节点插入到左子树中，否则：

4.把s所指节点插入到右子树中。（新插入节点总是叶子节点）

// 当树为空时，需要修改根结点指针值，所以参数传递双层指针
bool insertBST(BinaryTreeNode** pRoot, int key)
{
	if(*pRoot == NULL)
	{
		BinaryTreeNode* s = new BinaryTreeNode;
		s->value = key;
		s->left = s->right = NULL;
		*pRoot = s;
		return true;
	}
	else if((*pRoot)->value == key)
		return false;

	if((*pRoot)->value > key)
		return insertBST(&(*pRoot)->left, key);
	else
		return insertBST(&(*pRoot)->right, key);
}

在二叉查找树中删去一个节点，分三种情况讨论：

1.若*p节点为叶子节点，即PL（左子树）和PR（右子树）均为空树。由于删去叶子节点不破坏整棵树的结构，则只需修改其双亲节点的指针即可。

2.若*p节点只有左子树PL或右子树PR，此时只要另PL或PR直接成为其双亲节点*f的左子树（当*p是左子树）或右子树（当*p是右子树）即可。

3.若*p节点的左子树和右子树均不空。在删去*p之后，为保持其它元素之间的相对位置不变，可按中序遍历保持有序进行调整，可以有两种做法：其一是另*p的直接前驱（inorder predecessor）或直接后继（inorder successor）替代*p，然后再从二叉查找树中删去它的直接前驱（或直接后继）

bool deleteNode(BinaryTreeNode** pRoot)
{
	BinaryTreeNode* q, *s;
	if((*pRoot)->left == NULL && (*pRoot)->right == NULL)
	{
		delete *pRoot;
		*pRoot = NULL;
	}
	else if((*pRoot)->right == NULL)
	{
		q = (*pRoot)->left;
		(*pRoot)->value = q->value;
		(*pRoot)->left = q->left;
		(*pRoot)->right = q->right;

		delete q;
	}
	else if((*pRoot)->left == NULL)
	{
		q = (*pRoot)->right;
		(*pRoot)->value = q->value;
		(*pRoot)->left = q->left;
		(*pRoot)->right = q->right;

		delete q;
	}
	else
	{
		q = *pRoot;
		s = (*pRoot)->left;
		while(s->right)
		{
			q = s;
			s = s->right;
		}
		(*pRoot)->value = s->value;
		if(q != *pRoot)
			q->right = s->left;
		else
			q->left = s->left;

		delete s;
	}

	return true;
}

bool deleteBST(BinaryTreeNode** pRoot, int key)
{
	if(*pRoot == NULL)
		return false;

	if((*pRoot)->value == key)
		return deleteNode(pRoot);
	else if((*pRoot)->value > key)
		return deleteBST(&(*pRoot)->left, key);
	else
		return deleteBST(&(*pRoot)->right, key);
}

完整验证代码：

#include <iostream>

using namespace std;

struct BinaryTreeNode
{
	int value;
	BinaryTreeNode* left, *right;
};

// 指针parent指向pRoot的父节点，其初始调用值为NULL
// 若查找成功，指针pTarget指向目标节点，函数返回true
// 否则指针pTarget指向查找路径上访问的最后一个节点，函数返回false
// pTarget初始值为NULL，由于函数调用过程中需要修改其指针值，所以参数传递双层指针
bool searchBST(BinaryTreeNode* pRoot, int key, BinaryTreeNode* parent, BinaryTreeNode** pTarget)
{
	if(pRoot == NULL)
	{
		*pTarget = parent; 
		return false;
	}

	if(pRoot->value == key)
	{
		*pTarget = pRoot;
		return true;
	}
	else if(pRoot->value > key)
		return searchBST(pRoot->left, key, pRoot, pTarget);
	else
		return searchBST(pRoot->right, key, pRoot, pTarget);
}

// 当树为空时，需要修改根结点指针值，所以参数传递双层指针
bool insertBST(BinaryTreeNode** pRoot, int key)
{
	if(*pRoot == NULL)
	{
		BinaryTreeNode* s = new BinaryTreeNode;
		s->value = key;
		s->left = s->right = NULL;
		*pRoot = s;
		return true;
	}
	else if((*pRoot)->value == key)
		return false;

	if((*pRoot)->value > key)
		return insertBST(&(*pRoot)->left, key);
	else
		return insertBST(&(*pRoot)->right, key);
}

bool deleteNode(BinaryTreeNode** pRoot)
{
	BinaryTreeNode* q, *s;
	if((*pRoot)->left == NULL && (*pRoot)->right == NULL)
	{
		delete *pRoot;
		*pRoot = NULL;
	}
	else if((*pRoot)->right == NULL)
	{
		q = (*pRoot)->left;
		(*pRoot)->value = q->value;
		(*pRoot)->left = q->left;
		(*pRoot)->right = q->right;

		delete q;
	}
	else if((*pRoot)->left == NULL)
	{
		q = (*pRoot)->right;
		(*pRoot)->value = q->value;
		(*pRoot)->left = q->left;
		(*pRoot)->right = q->right;

		delete q;
	}
	else
	{
		q = *pRoot;
		s = (*pRoot)->left;
		while(s->right)
		{
			q = s;
			s = s->right;
		}
		(*pRoot)->value = s->value;
		if(q != *pRoot)
			q->right = s->left;
		else
			q->left = s->left;

		delete s;
	}

	return true;
}

bool deleteBST(BinaryTreeNode** pRoot, int key)
{
	if(*pRoot == NULL)
		return false;

	if((*pRoot)->value == key)
		return deleteNode(pRoot);
	else if((*pRoot)->value > key)
		return deleteBST(&(*pRoot)->left, key);
	else
		return deleteBST(&(*pRoot)->right, key);
}

void printInorder(BinaryTreeNode* pRoot)
{
	if(pRoot->left != NULL)
		printInorder(pRoot->left);

	printf("%d ", pRoot->value);

	if(pRoot->right != NULL)
		printInorder(pRoot->right);
}

int main()
{
	int a[10] = {62, 88, 58, 47, 35, 73, 51, 99, 37, 93};
	BinaryTreeNode* pRoot = NULL;
	printf("Build the binary search tree:\n");
	for(int i = 0; i < 10; i++)
	{
		insertBST(&pRoot, a[i]);
		printInorder(pRoot);
		printf("\n");
	}

    printf("which node do you want to delete?\n");
	int num = 0;
	while(scanf("%d", &num))
	{

		deleteBST(&pRoot, num);
		printInorder(pRoot);
		printf("\n");
	}

	return 0;
}