18. 二叉搜索树
一、什么是二叉搜索树
二叉搜索树 是一颗特殊的二叉树。它可以为空，如果不为空，它的 非空左子树 的 所有键值小于其根结点的键值，非空右子树 的 所有键值大于其根结点的键值，并且它的 左、右子树都是二叉搜索树。
二叉搜索树在二叉树的基础上扩展了一些方法。
ADT BinarySearchTree
{
Data:
二叉树T∈BinarySearchTree, Item∈ElementType,
Operation:
void PreOrderTraverse(BinarySearchTree T); // 先序遍历
void InOrderTraverse(BinarySearchTree T); // 中序遍历
void PostOrderTraverse(BinarySearchTree T); // 后序遍历
void LevelOrderTraverse(BinarySearchTree T); // 层次遍历
Posotion Find(BinarySearchTree T, ElementType X); // 查找元素X
Posotion FindMin(BinarySearchTree T); // 查找最小元素
Posotion FindMax(BinarySearchTree T); // 查找最大元素
void Insert(BinarySearchTree T, ElementType X); // 插入元素X
ElementType Delete(BinarySearchTree T, ElementType X); // 删除元素X
} ADT BinarySearchTree;
二、二叉搜索树的表示
typedef int ElementType;
typedef struct TreeNode
{
ElementType Data;
struct TreeNode * Left;
struct TreeNode * Right;
} TreeNode, * BinarySearchTree, * Position;
三、查找元素
/**
* @brief 查找元素
*
* @param T 二叉搜索树
* @param X 要查找的元素
* @return Position 如果找到返回结点的位置，否则返回NULL
*/
Position Find(BinarySearchTree T, ElementType X)
{
if (T == NULL)
{
return NULL;
}
while (T)
{
if (X > T->Data)
{
T = T->Right; // 往右子树查找
}
else if (X < T->Data)
{
T = T->Left; // 往左子树查找
}
else
{
return T; // 找到返回结点的位置
}
}
return NULL;
}
/**
* @brief 查找最小值
*
* @param T 二叉搜索树
* @return Position 最小值结点的位置
*/
Position FindMin(BinarySearchTree T)
{
if (T)
{
while (T->Left)
{
T = T->Left;
}
}
return T;
}
/**
* @brief 查找最大值
*
* @param T 二叉搜索树
* @return Position 最大值结点的位置
*/
Position FindMax(BinarySearchTree T)
{
if (T)
{
while (T->Right)
{
T = T->Right;
}
}
return T;
}
四、插入元素
/**
* @brief 插入元素
*
* @param T 二叉搜索树
* @param X 要插入的元素
* @return BinarySearchTree 指向二叉搜索树的指针
*/
BinarySearchTree Insert(BinarySearchTree T, ElementType X)
{
if (T == NULL)
{
T = (BinarySearchTree)malloc(sizeof(TreeNode));
T->Data = X;
T->Left = T->Right = NULL;
}
else
{
if (X < T->Data)
{
T->Left = Insert(T->Left, X); // 左子树递归插入
}
else if (X > T->Data)
{
T->Right = Insert(T->Right, X); // 右子树递归插入
}
else
{
T->Data = X; // 找到则更新元素
}
}
return T;
}
我们也可以使用非递归的方式实现插入元素。
/**
* @brief 插入元素
*
* @param T 二叉搜索树
* @param X 要插入的元素
* @return BinarySearchTree 指向二叉搜索树的指针
*/
BinarySearchTree Insert(BinarySearchTree T, ElementType X)
{
Position Node = T, Parent = T;
if (T == NULL)
{
T = (BinarySearchTree)malloc(sizeof(TreeNode));
T->Data = X;
T->Left = T->Right = NULL;
}
else
{
while (Node)
{
Parent = Node;
if (X < Node->Data) // 往左子树查找
{
Node = Node->Left;
}
else if (X > Node->Data) // 往右子树查找
{
Node = Node->Right;
}
else // 找到则更新元素
{
Node->Data = X;
return T;
}
}
Node = (BinarySearchTree)malloc(sizeof(TreeNode));
Node->Data = X;
Node->Left = Node->Right = NULL;
if (X < Parent->Data) // 插入左子树
{
Parent->Left = Node;
}
else // 插入右子树
{
Parent->Right = Node;
}
}
return T;
}
五、删除元素
二叉搜索树的删除元素分为三种情况：
- 要删除的结点是 叶结点：直接删除，并修改其父结点指针置为 NULL。
- 要删除的结点 只有一个孩子：将其父结点的指针指向要删除结点的孩子结点。
- 要删除的结点 有左、右两颗子树：用另一结点（右子树的最小元素或者左子树的最大元素）替代被删除结点。
/**
* @brief 删除元素
*
* @param T 二叉搜索树
* @param X 要删除的元素
* @return BinarySearchTree 指向二叉搜索树的指针
*/
BinarySearchTree Delete(BinarySearchTree T, ElementType X)
{
Position P = NULL;
if (T == NULL)
{
return NULL;
}
if (X < T->Data)
{
T->Left = Delete(T->Left, X); // 左子树递归删除
}
else if (X > T->Data)
{
T->Right = Delete(T->Right, X); // 右子树递归删除
}
else
{
if (T->Left && T->Right) // 被删除的结点存在左右子树
{
P = FindMax(T->Left); // 找到左子树最大值
T->Data = P->Data; // 删除右子树最小值
T->Left = Delete(T->Left, T->Data); // 删除左子树最大值
}
else // 被删除结点没有子结点或者只有一个子树
{
P = T;
if (T->Left == NULL) // 有右孩子或者无子结点
{
T = T->Right;
}
else if (T->Right == NULL) // 有左孩子或者无子结点
{
T = T->Left;
}
free(P);
}
}
return T;
}
我们也可以使用非递归的方式实现：
/**
* @brief 删除元素
*
* @param T 二叉搜索树
* @param X 要删除的元素
* @return BinarySearchTree 指向二叉搜索树的指针
*/
BinarySearchTree Delete(BinarySearchTree T, ElementType X)
{
Position P = T;
Position Parent = NULL;
if (T == NULL)
{
return NULL;
}
while (P != NULL)
{
if (X < P->Data)
{
Parent = P;
P = P->Left;
}
else if (X > P->Data)
{
Parent = P;
P = P->Right;
}
else
{
break;
}
}
if (P == NULL)
{
printf("要删除的元素不存在\n");
return T;
}
if (P->Left == NULL)
{
T = Shift(T, Parent, P, P->Right);
}
else if (P->Right == NULL)
{
T = Shift(T, Parent, P, P->Left);
}
else
{
Position S = P->Right; // 要删除结点的后继结点
Position sParent = P; // 要删除结点的后继结点的父结点
while (S->Left != NULL) // 循环结束后，S指向要删除结点的右子树的最小值
{
sParent = S;
S = S->Left;
}
ElementType Data = S->Data;
T = Shift(T, sParent, S, S->Right); // 将要删除结点的右子树的最小值的右孩子托孤
P->Data = Data; // 要删除结点的数据改为其右子树的最小值
}
return T;
}
/**
* @brief 托孤方法
*
* @param T 二叉搜索树
* @param Parent 要删除结点的父结点
* @param Node 要删除的结点
* @param Child 要删除结点的子结点
* @return BinarySearchTree 指向二叉搜索树的指针
*/
BinarySearchTree Shift(BinarySearchTree T, Position Parent, Position Node, Position Child)
{
if (Parent == NULL)
{
T = Child;
}
else if (Node == Parent->Left)
{
Parent->Left = Child;
}
else if (Node == Parent->Right)
{
Parent->Right = Child;
}
free(Node);
return T;
}
