二叉排序树的插入和删除

二叉排序树：又称“二叉查找树”，“二叉搜索树”。

二叉排序树是一颗空树，或者具有以下性质：

1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值.

2.若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值.

3.它的左、右子树也分别为二叉排序树。

//二叉排序树结构

typedef int ElemType;

typedef struct BstNode

{

ElemType data;

struct BstNode* parent; //双亲域

struct BstNode* leftchild; //左孩子

struct BstNode* rightchild; //右孩子

}BstNode, *BSTree;

插入思想：从根开始，用插入的值和当前指针的数据域比较， 如果相等， 则不能插入， 如果插入的值大于当前指针的数据域， 指针想右跑，否则， 指针向左跑。

删除思想：分三种情况：

1. 删除叶子和单分支， 只需调整相应的leftchild和rightchild即可.

2. 删除双分支， 需要找到其后继， 将两者数据交换，转化成删除其后继。

3. 删除的既是根结点，又是叶子结点，则要调整相应的根。

其思想总结成对所有节点的删除都归根于对叶子的删除，这一点很重要。

static BstNode* BuyNode()
{
    BstNode *s = (BstNode*)malloc(sizeof(BstNode));
    assert(s != NULL);
    memset(s, 0, sizeof(BstNode));

    return s;
}

static void FreeNode(BstNode *p)
{
    if (p == NULL)
    {
        return ;
    }
    free(p);
    p = NULL;
}

static BstNode* FindVal(BstNode *ptr, const ElemType x)
{
    if(ptr == NULL || x == END)
    {
        return NULL;
    }

    if(x == ptr->data)
    {
        return ptr;
    }
    else if(x > ptr->data)
    {
        return FindVal(ptr->rightchild, x);
    }
    else
    {
        return FindVal(ptr->leftchild, x);
    }
}

/**递归实现*/
bool Insert(BSTree *ptree, const ElemType x, BstNode *pa)
{
    if(ptree == NULL) return false;
    if(*ptree == NULL)
    {
        BstNode *s = BuyNode();
        s->data = x;
        s->leftchild = s->rightchild = NULL;
        *ptree = s;
        s->parent = pa;

        if(pa != NULL)
        {
            if(x > pa->data)
            {
                pa->rightchild = s;
            }
            else
            {
                pa->leftchild = s;
            }
        }

        return true;
    }

    BstNode *ptr = *ptree;

    if(x == ptr->data)
    {
        return false;
    }
    else if(x < ptr->data)
    {
        return Insert(&ptr->leftchild, x, ptr);
    }
    else
    {
        return Insert(&ptr->rightchild, x, ptr);
    }
}
/**迭代实现*/
bool InsertBST(BSTree *ptree,const ElemType val)
{
    if(ptree == NULL) return false;
    if(*ptree == NULL)
    {
        BstNode *s = BuyNode();
        s->data = val;
        s->leftchild = s->rightchild = NULL;
        *ptree = s;
        s->parent = NULL;

        return true;
    }

    BstNode *ptr = *ptree;
    BstNode *pa = ptr;

    while(ptr != NULL)
    {
        if(ptr->data == val)
        {
            return false;
        }
        else if(val > ptr->data)
        {
            pa = ptr;
            ptr = ptr->rightchild;
        }
        else
        {
            pa = ptr;
            ptr = ptr->leftchild;
        }
    }

    ptr = BuyNode();
    ptr->data = val;
    ptr->parent = pa;

    if(val > pa->data)
    {
        pa->rightchild = ptr;
    }
    else
    {
        pa->leftchild = ptr;
    }

    return true;
}

static BstNode *Next(BstNode *ptr)
{
    if(ptr->parent != NULL && ptr == ptr->parent->leftchild)
    {
        return ptr->parent;
    }
    else
    {
        ptr = ptr->rightchild;
        while(ptr != NULL && ptr->leftchild != NULL)
        {
            ptr = ptr->leftchild;
        }

        return ptr;
    }
}

static bool DeleteBST(BSTree *ptree, BstNode *ptr, const ElemType x)
{
    if(ptr->leftchild != NULL && ptr->rightchild != NULL)
    {
        BstNode *res = Next(ptr);
        ptr->data = res->data;
        ptr = res;
    }

    BstNode *pa = ptr->parent;
    BstNode *child = ptr->leftchild == NULL ? ptr->rightchild : ptr->leftchild;

    if(pa == NULL)
    {
        *ptree = child;
        if(child != NULL)
        {
            child->parent = NULL;
        }
    }
    else
    {
        if(ptr == pa->leftchild)
        {
            pa->leftchild = child;
        }
        else
        {
            pa->rightchild = child;
        }
    }

    FreeNode(ptr);

    return true;
}

bool RemoveBST(BSTree *ptree, const ElemType x)
{
    BstNode *ptr = NULL;
    if(ptree == NULL || *ptree == NULL||
      (ptr=FindVal(*ptree, x)) == NULL)
    {
        return false;
    }

    return DeleteBST(ptree, ptr, x);
}