二叉搜索（排序）树BST模板

定义：

typedef struct STnode
{
    int key;
    struct STnode *left;
    struct STnode *right;
    struct STnode *p;//记录父亲
}STnode;

插入节点：

STnode *insert(STnode *tree,STnode *my)
{
    STnode *parent;
    STnode cur;
    if (tree==NULL) tree=my;
    else
    {
        parent=NULL;
        cur=tree;
        whlie (cur!=NULL)//寻找my的父节点
        {
            parent=cur;
            if (my->key<cur->key) cur=cur->left;
            else cur=cur->right;
        }
        my->p=parent;
        if (my->key<parent->key) parent->left=my;
        else parent->right=my;
    }
    return tree;
}

查找节点：

STnode *find(STnode *tree,int my)//在tree中寻找节点
{
    STnode *cur;
    if (tree==NULL) return NULL;
    else
    {
        while (cur->key!=my)
        {
            if (my<cur->key) cur=cur->left;
            else cur=cur->right;
        }
        return cur;
    }
}

返回最大节点：

STnode *maxn(STnode *tree)
{
    STnode *cur=tree;
    while (cur->right)//等价于while (cur->right!=NULL)
    {
        cur=cur->right;
    }
    return cur;
}

返回最小节点：

STnode *minn(STnode *tree);
{
    STnode *cur=tree;
    while (cur->left)
    {
        cur=cur->left;
    }
    return cur;
}

查找节点在中序序列中的后继：

STnode *successor(STnode *my)
{
    STnode *cur;
    STnode *succ;
    if (my->right) return minn(my->right);//右子树非空
    else//右子树为空
    {
        if (my==my->p->left) return my->p;//该节点为父节点左孩子
         else//该节点为父节点右孩子
         {
                cur=my;
                succ=cur->p;
                while ((succ!=NULL)&&(cur!=succ->left))
                {
                    cur=cur->p;
                    succ=cur->p;
                }
                return succ;
         }
    }
}

查找节点在中序序列中的前驱：

STnode *predecessor(STnode *my)
{
    STnode *cur;
    STnode *pre;
    if (my->left) return maxn(my->left);
    else
    {
        if (my==my->p->right) return my->p;
        else
        {
            cur=my;
            pre=cur->p;
            while ((pre!=NULL)&&(cur!=pre->right))
            {
                cur=cur->p;
                pre=cur->p;
            }
            return pre;
        }
    }
}

删除节点：

STnode *Delete(STnode *tree,STnode *my)
{
    STnode *parent=my->p;
    STnode *succp;
    STnode *succ;
    if ((my->left==NULL)&&(my->right==NULL))
    {
        if (parent==NULL) return NULL;
        if (my==parent->left) parent->left=NULL;
        else parent->right=NULL;
    }
    else
    if ((my->left)&&(my->right==NULL))//仅有左孩子
    {
        if (parent==NULL) return tree->left;//特判删除根节点
        if (my==parent->left)//该节点为父节点的左孩子
        {
            parent->left=my->left;
            my->left->p=parent;
        }
        else//该节点为父节点的右孩子
        {
            parent->right=my->left;
            my->left->p=parent;
        }
    }
    else
    if ((my->left==NULL)&&(my->right))//仅有右孩子
    {
        if (parent==NULL) return tree->right;
        if (my==parent->left)
        {
            parent->left=my->right;
            my->right->p=parent;
        }
    }
    else//有两个孩子
    {
        succ=successor(my);//调用函数
        if (succ==my->right)//my的后继为my的右孩子
        {
            if (my==parent->left)
            {
                parent->left=succ;
                succ->p=parent;
                succ->left=my->left;
            }
            else
            {
                 parent->right=successor;
                 successor->p=parent;
                 successor->left=my_node->left;
            }
        }
        else//my的后继不为my的右孩子
        {
            succp=succ->p;
            succp->left=succ->right;
            succ->right->p=succ->p;//用my的后继节点右孩子替换该后继节点

            succ->right=my->right;
            succ->left=my->left;
            succ->p =my->p; //用后继节点替换my
        }
    }
     if(parent==NULL) return successor;
     else return tree;
}