二叉搜索树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;
}