学习《算法导论》 二叉查找树 总结

学习《算法导论》 二叉查找树 总结

二叉查找树

二叉查找树可以用链表结构来表示， 其中每个结点除了包括卫星数据外，还包括域left, right, parent; 它们分别指向结点的左儿子，右儿子和父结点.

二叉查找树的链表结构定义如下：

typedef int ElemType;
// 二叉树的链表结构
typdef struct TreeNode
{
ElemType data;
struct TreeNode* left;  // 指向左儿子
struct TreeNode* right; // 指向右儿子
struct TreeNode* parent; // 指向父结点
}TreeNode, *PointTree, *TreeNode;

结点元素数据要满足二叉查找树性质：

1. 设x为二叉查找树的一个结点，若y是x的左子树中的一个结点，则：y.data <= x.data ; 若y是x的右子树中的一个结点，则：x.data <= y.data

注意：这里说的是x的左子树中的一个结点，并不是说x的左结点，右结点类似.

二叉查找树的遍历

根据上面的二叉查找树性质，可以按顺序输出树中的所有结点. 这些算法有：

中序遍历算法：根结点的输出介于左子树和右子树之间

先序遍历算法：根结点的输出介于左子树和右子树之前

后序遍历算法.：根结点的输出介于左子树和右子树之后

中序遍历算法

VOS_VOID INORDED-TREE-WALK(PointTree RootNode)
{
if (RootNode != NULL)
{
INORDED-TREE-WALK(RootNode->left);
printf(RootNode->data);
INORDED-TREE-WALK(RootNode->right);
}

return;
}

先序遍历算法

VOS_VOID PREORDER-TREE-WALK(PointTree TreeRoot)
{
if (TreeRoot != NULL)
{
printf(TreeRoot->data);
PREORDER-TREE-WALK(TreeRoot->left);
PREORDER-TREE-WALK(TreeRoot->right);
}
}

后序遍历算法

VOS_VOID POSTORDER-TREE-WALK(PointTree TreeRoot)
{
if (TreeRoot != NULL)
{
POSTORDER-TREE-WALK(TreeRoot->left);
POSTORDER-TREE-WALK(TreeRoot->right);
printf(TreeRoot->data);
}
}

二叉查找树的查询

二叉查找树能支持以下操作：SEARCH, MINIMUM, MAXIMUM, SUCCESSOR和PREDECESSOR等. 并说明对高度为h的树， 它们都可以在O(h)时间内完成.

SEARCH

// 给定一关键字，查找树中是否存在; 递归算法
PointTree TREE-SEARCH(PointTree Tree, ElemType KeyElem)
{
if (Tree == NULL)
{
return NULL;
}
if (Tree->data == KeyElem)
{
return Tree;
}
else if (KeyElem < Tree->data)
{
// 递归
return TREE-SEARCH(Tree->left, KeyElem);
}
else
{
return TREE-SEARCH(Tree->right, KeyElem);
}
}

// 非递归算法
PointTree ITERATIVE-TREE-SEARCH(PointTree Tree, ELemType KeyElem)
{
PointTree CurrentTreeNode = Tree;
if (NULL == Tree)
return NULL;
while(CurrentTreeNode->data != KeyElem)
{
if (KeyElem < CurrentTreeNode->data)
CurrentTreeNode = CurrentTreeNode->left;
else
CurrentTreeNode = CurrentTreeNode->right;
}
return Tree;
}

MINIMUM

PointTree TREE-MINIMUM(PointTree TreeRoot)
{
PointTree CurrentNode = TreeRoot;

while(CurrentNode->left != NULL)
{
CurrentNode = CurrentNode->left;
}

return CurrentNode;
}

MAXIMUM

PointTree TREE-MAXIMUM(PointTree TreeRoot)
{
PointTree CurrentNode = TreeRoot;

while(CurrentNode->right != NULL)
{
CurrentNode = CurrentNode->right;
}

return CurrentNode;

后继

前驱和后继，这两个概念不好理解，在线性表，队列或栈中，前驱就是该结点前面一个结点，后继就是该结点后面一个结点；但是树不同，因为树有三种遍历方法，在前序遍历中结点的前驱和在后序遍历中结点的前驱是不一样的。后继也一样。所以在树结构中，谈到前驱和后继，是在某种遍历方法的前提下说的。

在看后继的算法之前，先看算法导论中的一道题：

题目：若二叉查找树T中某个结点x的右子树为空，且x有一个后继y，则：y就是x的最低祖先，且其左孩子也是x的祖先.

先解释下这个结论吧，结论比较绕口。我这里用集合来表示下吧：

{祖先 | 其左孩子也是x的} 这个集合中离x最近的祖先。

证明：给定结点x，其后继y存在，则：y>x. 由于y大于x，则y不可能在x的左子树中，又因为x的右子树为空。则y只能是结点x的祖先. 或x祖先的右子树中。

又因为y是其中大于x且最小的一个，则y不可能是其祖先的右子树，那么我们可以将范围缩小至y必定为x的祖先

又根据y>x,则x必定在y的左子树中，即y的左孩子也是x的祖先（x也是x的祖先）。

下面是算法

// 查找结点x的后继
PointTree TREE-SUCCESSOR(PointTree TreeNode)
{
// TreeNode的右子树非空，则TreeNode的后继就是
// 右子树中的最小结点
if (TreeNode->right != NULL)
{
return TREE-MINIMUM(TreeNode->right);
}
else
{
// 若右子树为空，则根据上面的题目，即查找TreeNode的最低祖
// 先，且其左孩子也是x的祖先，下面算法实现:
// 从TreeNode开始向上查找，直到找到某个结点的左孩子也是
// TreeNode的祖先为止
PointTree CurrentNode = TreeNode->parent;
// 条件：CurrentNode->right == TreeNode要求：CurrentNode要大于TreeNode
while((CurrentNode != NULL) && (CurrentNode->right == TreeNode))
{
TreeNode = CurrentNode;
CurrentNode = CurrentNode->parent;
}

return CurrentNode;
}

算法比较难理解，最好画个树的图来理解.

二叉查找树的插入

插入会引起二叉查找树的动态集合的变化，所以插入之后，要修改数据的结构。但要按照二叉查找树的原则来修改。话不多说，直接看算法：

// 将NewNode插入TreeRoot树中
VOS_VOID TREE-INSERT(PointTree TreeRoot, TreeNode NewNode)
{
PointTree CurrentNode = TreeRoot;
PointTree TmpNode = NULL;
// 若CurrentNode 为空，也即找到NewNode插入的位置
while(CurrentNode != NULL)
{
TmpNode = CurrentNode;
// 左子树
if (NewNode->data < CurrentNode->data)
{
CurrentNode = CurrentNode->left;
}
else // 右子树
{
CurrentNode = CurrentNode->right;
}
}

// 由上面可知，TmpNode就是NewNode的父结点
NewNode->parent = TmpNode;
// 若TmpNode为空，则说明该树是空树
if (NULL == TmpNode)
{
TreeRoot = NewNode;
}
else if (NewNode->data < TmpNode->data)
{
// NewNode放在TmpNode的左子树
TmpNode->left = NewNode;
}
else
{
// NewNode放在TmpNode的右子树
TmpNode->right = NewNode;
}

return;
}

二叉查找树的删除

删除操作有三种情况：

1. 若删除的结点z没有子女，即z为叶子结点，则修改其父结点，将它的子女改为NULL；

2. 若z只有一个子女，则通过在其子结点与父结点间建立一条链来删除z；

3. 若z有两个子女，则找到z的后继（后继也就是：z的右子树的最左边的结点，所以它是没有左子女的）；

代码如下：

VOS_VOID TREE-DELETE(PointTree TreeRoot, TreeNode DeleteNode)
{
TreeNode CurrentNode = NULL;
TreeNode ChildNode = NULL;
// 第一种情况和第二种情况：z最多只有一个子结点
if (DeleteNode->left == NULL || DeleteNode->right != NULL)
{
CurrentNode = DeleteNode;
}
else
{
// 第三种情况：找到z的后继
CurrentNode = TREE-SUCCESSOR(DeleteNode);
}

// ChildNode被置为CurrentNode的非NULL子女结点
if (CurrentNode->left != NULL) // 即这里是第二种情况或第三种情况
{
ChildNode = CurrentNode->left;
else // 即这里是第一种情况或第二种情况
{
ChildNode = CurrentNode->right;
}

if(ChildNode != NULL) // 这就是第二种情况
{
ChildNode->parent = CurrentNode->parent;
}

if (CurrentNode->parent == NULL) // CurentNode为DeleteNode，但是无祖先，说明DeleteNode为根结点
{
TreeRoot = ChlidNode;
}
else if (CurrentNode == CurrentNode->parent->left)
{
CurentNode->parent->left = ChlidNode;
}
else
{
CurentNode->parent->right = ChildNode;
}

if (CurentNode != DeleteNode)
{
DeleteNode->data = CurentNode->data;
}

free(CurentNode);
return;
}

这个删除算法没看懂，有三种情况比较好理解，但是这个算法没看明白。

下次找资料好好看看

下面再介绍一种二叉查找树的删除操作算法，这个比较好理解，实际上就是分别讨论了三种情况：

/*删除一个节点
p为树根节点指针
node_value要删除的节点的值
*/
bool DeleteTreeNode(Tree * p,int node_value)
{
Tree * t = FindNode(p,node_value);
if(t == NULL)
{
return false;
}
if((t->left == NULL)&&(t->right == NULL))
{/*没有子节点*/
Tree* tmp = t;
if(tmp->parent->left == tmp)
{
tmp->parent->left = NULL;
}
else
{
tmp->parent->right = NULL;
}
delete tmp;
tmp = NULL;
}
else if((t->left == NULL)||(t->right == NULL))
{/*一个子节点*/
Tree* tmp = t;
if(tmp->parent->left == tmp)
{
tmp->parent->left = (tmp->left ==NULL)?tmp->right :tmp->left;
}
else
{
tmp->parent->right = (tmp->left ==NULL)?tmp->right :tmp->left;
}
delete tmp;
tmp = NULL;
}
else
{/*两个子节点*/
Tree* s = Successor(t);
if(s == NULL)
{
return false;
}
t->node_value = s->node_value ;
DeleteTreeNode(s);

}
}