算法打基础——二叉查找树Ⅰ

二叉查找树是一种基本的数据结构。 它的优势在于其高效的查询，排序过程，且它也支持多种操作，如插

入、删除、前趋，后接等。二叉查找树常被用于其他抽象结构的一个基础，比如字典、优先队列、集合、多

集等。总之，就是用处多多。

二叉查找树基本上各种操作的效率跟树的高度都是直接成比例的。所以查找树的结构就非常重要了，平衡的

结构可使得效率更高。这就带来了随机化版本的二叉树。 具体各种操作的分析在这一节中讲，随机化版本的

分析涉及数学很多，放在下一讲中，下一讲实际上也写好了，就放在候选区了~ 

这一讲的主要知识点有：1.二叉树基本结构  2.查找操作  3.插入删除操作

 

1.二叉树基本结构

二叉树的每个节点(node)就是一个对象，每个node里主要有key、卫星数据(就是主要数据)、left(存储左儿

子), right（存储右儿子）,parent（存储父节点）。如果相应节点不存在，则为NULL

二叉查找树的组织方式很简单，当一个节点进来后，与树中节点比较，如果大于当前节点key，就进入它的右

子树，否则进入左子树。知道找到NULL的位置。下面是两个BST的例子

 二叉树的一个基本操作是树的遍历。树的遍历也主要有三种：前序、中序、后序。其主要区别看下面中序

的伪代码就可以很好理解了。

INORDER-TREE-WALK(x)

1 　　if x != NIL
2 　　　　INORDER-TREE-WALK(x.left)
3　　　　 print x.key
4 　　　　INORDER-TREE-WALK(x.right)

中序就是打印的命令放在了左、右递归的中间。 而实际上，根据二叉查找树的性质，中序遍历打印出来的结

构就是所有键值按从小到大顺序排序后的结果！

树的遍历作为一种遍历，当然其时间复杂度就是Θ(n)

 

 2.查找操作

二叉查找树作为一种查找树，当然常见操作就是查找了。 查询除了常用的查找某个关键字之外，还有找最

大、最小、后续、前趋关键字。对高度为h的的树，这些操作的时间复杂度都是Θ(h)

 查找关键字

TREE-SEARCH(x; k)
1 　　if x == NIL or k == x.key
2 　　　　return x
3 　　if k < x.key
4 　　　　return TREE-SEARCH(x.left; k)
5 　　else return TREE-SEARCH(x.right; k)

其过程是沿着树的根节点比较着往下找，大则右，小则左。所以时间复杂度是O(h)

最大关键字与最小关键字

TREE-MINIMUM(x)

1 　　while x.left != NULL
2 　　　　x = x.left
3 　　return x

TREE-MAXIMUM(x)
1 　　while x.right != NULL
2 　　　　x = x.right
3 　　return x

最大与最小是分别沿着右子树或左子树一直下降，时间复杂度O(h)

前趋和后续 

TREE-SUCCESSOR(x)
1 　　if x.right != NULL
2 　　　　return TREE-MINIMUM(x.right)
3 　　y = x.p
4 　　while y != NIL and x == y.right
5 　　　　x = y
6 　　　　y = y.p
7 　　return y

后继操作的过程需要分为两种情况：1 存在右子树，则是右子树当中的最小值(比它大的元素里面的最小值，合

理！)；2 只有左子树，则顺流而上，找到第一次做左子树的地方。图例见下：case1-15  case2-13

前趋的过程与后继是对称的，伪代码就不写了，后面附的代码里面会有。

 

 3.插入删除操作

插入与删除操作因为需要改变一些东西，且还要维持数据结构的性质，稍微会复杂一些

TREE-INSERT(T; z)
1 　　y = NULL
2 　　x = T.root
3　　 while x != NULL
4 　　　　y = x
5 　　　　if z.key < x.key
6　　　　 x = x.left
7 　　　　else x = x.right
8 　　z.p = y
9 　　if y == NULL
10 　　　 T.root = z 　　// tree T was empty
11 　elseif z.key < y.key
12 　　　 y.left = z
13 　else y.right = z

在伪代码里面，y始终指向x的父节点。实现主要注意当是空树的时候，需要将当前节点作为根。否则就是一路下

去直到找到空位置

删除操作比较复杂，需要分为三种情况，所以这里先做分析。 三种情况对应不同的操作方法，1是既没有左子树

也没有右子树  2只有一个子树 3同时有两个子树。对于1直接操作即可； 对于2删除当前节点时，将其子树接到

节点的父节点上去；对于3，需要找到待删除节点的后继节点,然后用这个后继节点替代当前节点并删除那个后继

节点之前的位置。 注意：找到的后继节点是没有左子树的否则它的前趋就不可能是那个待删除节点了。下面用

图示例这三种情况：

下面给出伪代码：

TREE-DELETE(T, z)
1 　　if left[z] = NIL or right[z] = NIL
2 　　　　then y ← z
3 　　　　else y ← TREE-SUCCESSOR(z)
4 　　if left[y] = NIL
5 　　　　then x ← left[y]
6 　　　　else x ← right[y]
7　　 if x = NIL
8 　　　　then p[x] ← p[y]
9 　　if p[y] = NIL
10 　　　then root[T ] ← x
11 　　　else if y = left[p[y]]
12 　　　　　　then left[p[y]] ← x
13 　　　　　　else right[p[y]] ← x
14　  if y = z
15 　　 then key[z]← key[y]
16 　　　　　copy y’s satellite data into z
17 　 return y

其过程与上面的三种情况顺序是不同的。 首先y是记录需要删除的节点的，即y必然有一个子树是空的；x是记录

y的一个子节点的，若有就是相应子节点，没有则默认是右边的(Row 6); Row9-13是执行将删除点父节点的更

新操作。Row14-16 是如果需要是替换的情况作一个替换。

 

 下面附上C++实现的BST：

#include<iostream>
#include<cstdlib>
#include<ctime>
using namespace std;

#define random(x)(rand()%x)

class BSTree;

class Node{
public:
    int key;
    Node* lchild;
    Node* rchild;
    Node* parent;
    Node(int value, Node* lc, Node* rc,Node* pa):key(value),
        lchild(lc),rchild(rc),parent(pa){};
    friend class BSTree;
};

class BSTree
{
public:
    Node* root;
    BSTree(Node* r){root=r;}
    void inorderwalk(Node* t) const;
    Node* search(Node* t,int ele)const;
    Node* findmax(Node* t) const;
    Node* findmin(Node* t) const;
    Node* predecessor(Node* t) const;
    Node* successor(Node* t) const;
    void insert(int k, Node* &t);
    void dele(int k, Node* &t);
};

void BSTree::inorderwalk(Node* t) const
{
    if(t!=NULL)
    {
        inorderwalk(t->lchild);
        cout<<t->key<<" ";
        inorderwalk(t->rchild);
    }
}
Node* BSTree::search(Node* t, int ele) const
{
    if(t==NULL)
    {
        cout<<"Not Found"<<endl;
        return t;
    }
    if(t->key==ele)
    {
        return t;
    }
    if(ele< (t->key))
        return search(t->lchild,ele);
    else return search(t->rchild,ele);
}

Node* BSTree::findmax(Node *t) const
{
    while(t->rchild!=NULL)
    {
        t=t->rchild;
    }
    return t;
}
Node* BSTree::findmin(Node *t) const
{
    while(t->lchild!=NULL)
    {
        t=t->lchild;
    }
    return t;
}
Node* BSTree::predecessor(Node *t) const
{
    if(t->lchild!=NULL)
    {
        return findmax(t->lchild);
    }
    while(t->parent->lchild==t)
    {
        t=t->parent;
    }
    return t->parent;
}
Node* BSTree::successor(Node* t) const
{
    if(t->rchild!=NULL)
    {
        return findmin(t->rchild);
    }
    while(t->parent->rchild==t)
    {
        t=t->parent;
    }
    return t->parent;
}
// Node* &rt   是传进来的root的一个引用，即它跟root是一个指针，只是一个别名
void BSTree::insert(int k, Node * &rt)
{
    //空树的情况
    if(rt==NULL)
    {
        // 这个new返回是什么？ 应该就是一个指针，因为必须赋值给指针
        Node* nd = new Node(k,NULL,NULL,NULL);
        rt=nd;
        return;
    }
    if(rt->key>k)
    {
        insert(k,rt->lchild);
    }
    else
    {
        insert(k,rt->rchild);
    }

}
//注意所有调用dele函数时，参数都必须是传进来的参数t的某个直接相关元素
//否则无法操作
// 实际上 insert函数也有这个性质
void BSTree::dele(int k, Node *&t)
{
    if(t==NULL)
    {
        cout<<"Can't find"<<endl;
        return;
    }
    if(t->key==k)
    {
        if((t->lchild!=NULL)&&(t->rchild!=NULL))
        {
            Node* nd = successor(t);
            t->key = nd->key;
            dele(nd->key,t->rchild);
            //dele(nd->key,nd); 这样写是错误的！
        }
        else{
            t= (t->lchild!=NULL)?t->lchild:t->rchild;

        }
    }
    else if(t->key>k)
    {
        dele(k,t->lchild);
    }
    else dele(k,t->rchild);
}



int main()
{
    srand(time(0));
    int keys[10],i;
    for(i=0;i<10;i++)
        keys[i]=random(500);
    BSTree* tree = new BSTree(NULL);
    for(i=0;i<8;i++)
    {
        tree->insert(keys[i],tree->root);
    }
    tree->inorderwalk(tree->root);
        cout<<endl;
    Node* n = tree->findmax(tree->root);
    cout<<n->key<<endl;
    n = tree->findmin(tree->root);
    Node* n2=tree->successor(n);
    cout<<n2->key<<endl;
    tree->dele(keys[4],tree->root);
    tree->inorderwalk(tree->root);
    cout<<endl;




    return 0;
}