数据结构之二叉搜索树

1.二叉搜索树

定义：

二叉搜索树(Binary search tree)是一棵**可能为空**的树，一棵非空的二叉搜索树满足以下特征：
- 每个元素有一个关键值，并且没有任意两个元素有相同的关键值；因此，所有的关键值都是唯一的；
- 根节点左子树的关键值（如果有的话）小于根节点的关键值；
- 根节点右子树的关键值（如果有的话）大于根节点的关键值；
- 根节点的左右子树也都是二叉搜索树。

有重复值的二叉搜索树：

（binary search tree with duplicates）用小于等于替代上面特征二中的小于，用大于等于替代特征三中的大于.

带索引的二叉搜索树：

（indexed binary search tree）源于普通的二叉搜索树，是在每一个节点中添加一个LeftSize域，这个域的值是给节点
左子树的元素个数加1. 

搜索（O(h) h为树的高度）：

假设查找关键值为k的元素，那么先从根开始。如果根为空，那么搜索树不包含任何元素，查找失败；否则，将k与根的关键值
比较。如果k小于根节点的关键值，那么就不需要搜索右子树；如果k大于根节点的关键值，那么就不需要搜索左子树；如果
k等于根节点的内容，则查找成功，搜索终止。在子树中的查找与此类似。

template<class E,class K>
bool BSTree<E,K>::Search(const K& k,E& e)const
{
    //从树根开始查找
    BinaryTreeNode<E> *p = root;
    while(p){
        if(k < p->data) p = p->LeftChild;
        else if(k > p->data) p = p->RightChild;
        else{//找到元素
            e = p->data;
            return true;
        }
    }
    return false;
}

插入（O(h) h为树的高度）：

若在二叉搜索树中插入一个新元素e，首先要验证e的关键值与树中的已有元素的关键值是否相同，这可以通过用e的关键值对
二叉搜索树进行搜索实现。如果搜索不成功，则在搜索中断的地方插入新元素。 

template<class E,class K>
BSTree<E,K>& BSTree<E,K>::Insert(const E& e)
{//如果不出现重复，则插入e
    BinaryTreeNode<E> *p = root,//搜索指针
                      *pp = 0;//搜索指针的父节点
    //寻找插入点
    while(p){//检查p->data
        pp = p;
        if(e < p->data) p = p->LeftChild;
        else if(e > p->data) p = p->RightChild;
        else throw BadInput();//出现重复
    }

    //为e建立一个节点，并将该节点连接至pp
    BianryTreeNode<E> r = new BianryTreeNode<E>(e);
    if(root){
        if(e < pp->data) pp->LeftChild = r;
        else pp->RightChild = r;
    }else{
        root = r;
    }
    return *this;
}

删除（O(h) h为树的高度）：

考虑包含删除元素的节点p的三种情况：1）p是树叶；2）p只有一个非空子树；3）p有两个非空子树
1)丢弃树叶节点
2）如果p是根，将p丢弃，p的唯一子树的根成为新的搜索树的根节点。如果p有父节点pp，则修改pp的指针，使得pp指向p的
唯一孩子，然后删除节点p。
3)要删除一个左右子树都不为空的节点中元素，只需要将该元素替换为它的左子树中的最大元素或右子树中的最小元素。可以
按照下述方法找到左子树中的最大元素：首先移动到子树的根，然后沿着各节点的右孩子指针移动，直到右孩子指针为0为止。
类似地，可以找到右子树中的最小元素。

template<class E,class K>
BSTree<E,K>& BSTree<E,K>::Delete(const K& k,E& e)
{//删除关键值为k的元素，并将其放入e中
    BinaryTreeNode<E> *p = root,//搜索指针
                      *pp = 0;//搜索指针的父节点

    while(p && p->data != k){//移动到p的孩子
        pp = p;
        if(k < p->data) p = p->LeftChild;
        else p = p->RightChild;
    }
    if(!p) throw BadInput();//没有关键值为K的元素 

    e = p->data;//保存欲删除的元素

    //对树进行重构
    //处理p有两个孩子的情形
    if(p->LeftChild && p->RightChild){
        //转换成有0或1个孩子的情形
        //在p的左子树中寻找最大元素
        BianryTreeNode<E> *s = p->LeftChild,*ps = p;//s的父节点
        while(s->RightChild){
            ps = s;
            s = s->RightChild;
        }
        //将最大元素从s移动到p
        p->data = s->data;
        p = s;
        pp = ps;
    }

    //p最多有一个孩子
    //在c中保存孩子指针
    BianryTreeNode<E> *c;
    if(p->LeftChild) c = p->LeftChild;
    else c = p->RightChild;

    //删除p
    if(p == root) root =c;
    else{//p是pp的左孩子还是pp的右孩子？
        if(p == pp->LeftChild)
            pp->LeftChild = c;
        else pp->RightChild = c;
    }
    delete p;
    return *this;
}

二叉搜索树的高度

一棵n元素的二叉搜索树的高度可以和n一样大。但是可以证明，当使用上面的随机插入和删除操作时，二叉搜索树的平均高度是
O(logn).因此，每一棵树操作的平均时间是O(logn).