《算法导论》CLRS算法C++实现（十）P151 二叉查找树

第十二章 二叉查找树

前几章比较简单，都是数据结构里的简单内容，以前也都写过，这次就不浪费时间在这些上面了。直接写二叉查找树、红黑树。

在二叉查找树上执行的基本操作的时间与树的高度成正比。对一棵含n个结点的完全二叉树，这些操作的最坏情况运行时间为O(lgn)。但是如果二叉查找树是含n个结点的线性链，则这些操作的最坏情况运行时间为O(n)。

二叉查找树的基本操作有：遍历，查找，求最大值，求最小值，求直接前驱，求直接后继，插入，删除等。

1、遍历

根据二叉查找树的性质，可以用一个递归算法按排列顺序输出树中的所有关键字。这种算法称为中序遍历算法。因为对任一子树根的关键字在输出时介于左子树和右子树的关键字之间。

INORDER-TREE-WALK(x)

if x ≠ NIL
    then INORDER-TREE-WALK(left[x])
    print key[x]
    INORDER-TREE-WALK(right[x])

 2、查找（搜索）

给定指向树根的指针和关键字k，算法返回指向包含关键字k的结点的指针，如果不存在，返回NIL。算法过程从树的根结点开始进行查找，并沿着树下降，对碰到的每个结点x，就比较k和key[x]，如果相同，则搜索结束，如果k小于key[x]，则继续查找x的左子树，如果k大于key[x]，则继续在x的右子树中查找。算法如下：

ITERATIVE-TREE-SEARCH(x, k)

while x ≠ NIL and k ≠ key[x]
    do if k < key[x]
        then x ← left[x]
    else x ← right[x]
return x

3、最大值、最小值

要查找二叉树中具有最小关键字的元素，只要从根结点开始，沿着各结点的left指针查找下去，直到遇到NIL为止，如下图从15->6->3->2。类似地，要查找二叉树中具有最大关键字的元素，只要从根结点开始，沿着各结点的right指针查找下去即可，如下图15->18->20。

算法如下：

TREE-MINIMUM (x)

while left[x] ≠ NIL
    do x ← left[x]
return x

4、前驱和后继

给定一个二叉查找树中的结点，有时候要求找出在中序遍历下它的前驱或后继。其实前驱就是查找其左子树的最大值，而后继就是查找其右子树的最小值。算法如下：

TREE-SUCCESSOR(x)

if right[x] ≠ NIL
    then return TREE-MINIMUM (right[x])
y ← p[x]
while y ≠ NIL and x = right[y]
    do x ← y
    y ← p[y]
return y

对一棵高度为h的二叉查找树，动态集合操作search，minimum，maximum，successor，predecessor等的运行时间均为O(h)。

5、插入和删除

插入操作较为简单，从根结点开始，并沿树下降。指根据待插入结点和当前结点的比较结果，可以决定向左转或者向右转。直到x成为NIL时为止。如下图：在二叉查找树中插入结点13。

 

TREE-INSERT(T, z) 

y ← NIL
x ← root[T]
while x ≠ NIL
    do y ←  x
    if key[z] < key[x]
        then x ← left[x]
    else x ← right[x]
p[z] ← y
if y = NIL
    then root[T] ← z
else if key[z] < key[y]
    then left[y] ← z
else right[y] ← z

在二叉查找树中删除结点的情况较为复杂，需要分三种情况考虑

（1）该结点没有子女，直接删除即可。

（2）只有一个左孩子或者右孩子，则将唯一的孩子接到将删除结点原来的位置上，再删除结点即可。

（3）有两个子女，则将其直接后继替换到将删除结点原来的位置上，再将其直接后继删除即可。

以上三种情况分别如下图（a）（b）（c）所示。

TREE-DELETE(T, z)

if left[z] = NIL or right[z] = NIL
    then y ← z
else y ← TREE-SUCCESSOR(z)
if left[y] ≠ NIL
    then x ← left[y]
else x ← right[y]
if x ≠ NIL
    then p[x] ← p[y]
if p[y] = NIL
    then root[T] ← x
else if y = left[p[y]]
    then left[p[y]] ← x
else right[p[y]] ← x
if y ≠ z
    then key[z] ← key[y]
    copy y's satellite data into z
return y

 对高度为h的二叉查找树，动态集合操作insert和delete的运行时间为O(h)。

 C++源码： 

#include <iostream>

using namespace std;

class BinarySearchTree;
class BinaryNode
{
    public:
        int element;
        BinaryNode* leftChild;
        BinaryNode* rightChild;
        BinaryNode(int value, BinaryNode* lChild, BinaryNode* rChild):element(value), leftChild(lChild), rightChild(rChild){};
        friend class BinarySearchTree;
};

class BinarySearchTree
{
    public:
        BinaryNode* root;
        BinarySearchTree(BinaryNode* t){root = t;}
        void walk(BinaryNode * & t)const;
        BinaryNode* find(int x, BinaryNode* t)const;
        BinaryNode* findMax(BinaryNode* t)const;
        BinaryNode* findMin(BinaryNode* t)const;
        BinaryNode* predecessor(BinaryNode * & t)const;
        BinaryNode* successor(BinaryNode * & t)const;
        void insert(int x, BinaryNode * & t);
        void remove(int x, BinaryNode * & t);
};

void BinarySearchTree::walk(BinaryNode * & t) const
{
    if(t != NULL)
    {
        walk(t->leftChild);
        cout << t->element << " ";
        walk(t->rightChild);
    }
}

BinaryNode* BinarySearchTree::find(int x, BinaryNode* t) const
{
    while(t != NULL)
    {
        if(x < t->element)
            t = t->leftChild;
        else if(x > t->element)
            t = t->rightChild;
        else
            return t;
    }
    return NULL;
}

BinaryNode* BinarySearchTree::findMax(BinaryNode* t) const
{
    if(t != NULL)
    {
        while(t->rightChild != NULL)
        {
            t = t->rightChild;
        }
    }
    return t;
}

BinaryNode* BinarySearchTree::findMin(BinaryNode* t) const
{
    if(t != NULL)
    {
        while(t->leftChild != NULL)
        {
            t = t->leftChild;
        }
    }
    return t;
}

BinaryNode* BinarySearchTree::predecessor(BinaryNode * & t) const
{
    if(t != NULL)
    {
        if(t->leftChild != NULL)
        {
            return findMax(t->leftChild);
        }
        return NULL;
    }
    return NULL;
}

BinaryNode* BinarySearchTree::successor(BinaryNode * & t) const
{
    if(t != NULL)
    {
        if(t->rightChild != NULL)
        {
            return findMin(t->rightChild);
        }
        return NULL;
    }
    return NULL;
}

void BinarySearchTree::insert(int x, BinaryNode * & t)
{
    if(t == NULL)
        t = new BinaryNode(x, NULL, NULL);
    else if(x < t->element)
        insert(x, t->leftChild);
    else if(x > t->element)
        insert(x, t->rightChild);
    else
    {
        cerr << "Duplicate Element!" << endl;
    }
}

void BinarySearchTree::remove(int x, BinaryNode * & t)
{
    if(t == NULL)
         cerr << "Not exist!" << endl;
    if(x < t->element)
        remove(x, t->leftChild);
    else if(x > t->element)
        remove(x, t->rightChild);
    else if((t->leftChild != NULL) && (t->rightChild != NULL))
    {
        t->element = findMin(t->rightChild)->element;
        remove(t->element, t->rightChild);
    }
    else
    {
        BinaryNode* temp = t;
        t = (t->leftChild != NULL) ? t->leftChild : t->rightChild;
        delete temp;
    }
}