数据结构与算法（16）—— 二叉排序树

二叉排序树

• 二叉排序树(Binary Search Tree 也叫二叉搜索树)或者是一棵空树，或者是具有以下性质的二叉树
  ①若左子树不空，则左子树上所有结点的值均小于它的根结点的值。
  ②若右子树不空，则右子树上所有结点的值均大于它的根结点的值。
  ③它的左右子树也是一棵二叉排序树。
• 算法思想
  • 由于二叉排序树的特点(左子树<根结点<右子树),所以每次查找一个关键字，需要先和根结点进行比较：
    如果这个关键字小于根结点的值，则再到这个根结点的左子树进行同样的比较操作一直进行下去直到找到该关键字，表示查找成功，或者是空指针，表示查找失败。
    如果这个关键字大于根结点的值，则再到这个根结点的右子树进行同样的比较操作一直进行下去直到找到该关键字，表示查找成功，或者是空指针，表示查找失败。
    • 查找关键字代码

  int  FindBSTree(BSTree *BStree, BSDataType data)
{
    BSTree *cur = BStree;
    //根节点为空，即二叉树为空，返回0
    if (BStree == NULL)
    {
        return 0;
    }
    while (cur != NULL)
    {
        if (cur->_data == data)
        {
            return 1;
        }
        else if (cur->_data > data)
        {
            cur = cur->_pleft;
        }
        else
            cur = cur->_pright;
    }
    //cur==NULL即没有找到元素和data相等，返回0
    return 0;
}

//递归查找
int  FindBSTree(BSTree *BStree, BSDataType data)
{
    BSTree *cur = BStree;
    if (BStree == NULL)
    {
        return 0;
    }
    if (cur->_data == data)
    {
        return 1;
    }
    else if (cur->_data > data)   
    {
        return FindBSTree(BStree->_pleft,data);
    }
    else
    {
        return FindBSTree(BStree->_pright, data);
    }
}

• 插入关键字代码
  1)空树：直接插入新结点返回成功
  2)树不空：检查是否存在关键字重复的结点：
  ①存在：返回插入失败
  ②不存在：检查根结点的值和待插入关键字值的大小关系递归插入左右子树

//插入
int InsertBSTree(BSTree **BStree, BSDataType data)
{
    BSTree *cur  = NULL;
    BSTree *parent = NULL;
    assert(BStree);
    cur = *BStree;
    //1.若二叉树为空
    if (NULL == *BStree)    
    {
        *BStree = BuyNode(data);
    }
    //2.若二叉树不为空  
    else
    {
        //①.寻找插入的位置
        while (cur != NULL)
        {
            parent = cur;
            if (data < cur->_data)
            {         
                cur = cur->_pleft;
            }
            else if (data > cur->_data)
            {
                cur = cur->_pright;
            }
            else
            {
                return 0;
            }
        }
        //②.建立新结点
        cur = BuyNode(data);
        //③.data若比双亲大，则插右边，若比双亲小，则插左边
        if (data < parent->_data)
        {
            parent->_pleft = cur;
        }
        else
        {
            parent->_pright = cur;
        }
    }
    return 1;
}

//递归插入
int InsertBSTree(BSTree **BStree, BSDataType data)
{
    BSTree *cur = NULL;
    BSTree *parent = NULL;
    assert(BStree);
    cur = *BStree;
    if (NULL == *BStree)
    {
        *BStree = BuyNode(data);
    }
    else
    {
        if (data > cur->_data)
        {
            return InsertBSTree(&(*BStree)->_pright, data);
        }
        else if (data < cur->_data)
        {
            return  InsertBSTree(&(*BStree)->_pleft, data);
        }
        else
        {
            return 0;
        }
    }
    return 1;
}

    * 构造代码

    * 删除结点
        * ①删除的是叶子结点
            * 方法：直接删去该结点即可
        * ②删除的是仅有左子树或者右子树的结点
            * 方法：“子承父业”
        * ③删除的是左右子树都有的结点
            * 仿照②类型，先将一个孩子“继承父业”，另一个孩子“归顺”于这个孩子

方法：找到待删除结点的直接前驱或者直接后继结点，用该结点来替换待删除结点，再删除该结点。

int  DeleteBSTree(BSTree **BStree, BSDataType data)
{
    BSTree *cur = NULL;
    BSTree *del = NULL;      //要删除的结点
    BSTree *parent = NULL;   //要删除结点的双亲结点
    assert(BStree);
    cur = *BStree;
    if (*BStree == NULL)
    {
        return 0;
    }
    //寻找要删除的点
    while (cur != NULL)
    {
        if (cur->_data == data)
        {
            break;
        }
        else if (data < cur->_data)
        {
            parent = cur;
            cur = cur->_pleft;
        }
        else
        {
            parent = cur;
            cur = cur->_pright;
        }
    }
    if (cur == NULL)
    {
        //证明要删除的元素不在二叉搜索树内
        return 0;
    }
    //只有右孩子或者叶子
    if (cur->_pleft == NULL)
    {
        //如果是根节点，让根节点指向它的右子树
        if (cur == *BStree)
        {
            *BStree = (*BStree)->_pright;
        }
        else
        {
            //判断cur是双亲的左孩子还是右孩子
            //双亲指向cur的右孩子，因为左孩子为空
            if (parent->_pleft == cur)
            {
                parent->_pleft = cur->_pright;
            }
            else
            {
                parent->_pright = cur->_pright;
            }
        }
    }
    //只有左孩子
    else if (cur->_pright == NULL)
    {
        //如果是根节点，让根节点指向它的左子树
        if (cur == *BStree)
        {
            *BStree = (*BStree)->_pleft;
        }
        else
        {
            //判断cur是双亲的左孩子还是右孩子
            //双亲指向cur的左孩子，因为右孩子为空
            if (parent->_pleft == cur)
            {
                parent->_pleft = cur->_pleft;
            }
            else
            {
                parent->_pright = cur->_pleft;
            }

        }
    }
    //左右孩子均存在
    else
    {
        del = cur->_pright;
        parent = cur;
        //找到右子树里面最小的一个，覆盖要删除的结点
        while (del->_pleft)
        {
            parent = del;
            del = del->_pleft;
        }
        //将找到的结点的值赋给要删除的结点
        cur->_data = del->_data;
        //删除replace 
        if (parent->_pleft == del)
        {
            parent->_pleft = NULL;
            cur = del;
        }
        else
        {
            parent->_pright = NULL;
            cur = del;
        }
    }
    free(cur);
    cur = NULL;
    return 1;
} 

//递归删除
int DeleteBSTree(BSTree **BStree, BSDataType data)
{
    BSTree *del = NULL;
    BSTree *cur = NULL;

    assert(BStree);
    if ((*BStree) == NULL)
    {
        return 0;
    }
    if (data < (*BStree)->_data )
    {
        return DeleteBSTree(&(*BStree)->_pleft,data);
    }
    else if (data > (*BStree)->_data )
    {
        return DeleteBSTree(&(*BStree)->_pright, data);
    }
    else
    {
        cur = *BStree;
        if ((*BStree)->_pleft == NULL)
        {
            *BStree = (*BStree)->_pright;
            free(cur);
            cur = NULL;
        }
        else if ((*BStree)->_pright == NULL)
        {
            *BStree = (*BStree)->_pleft;
            free(cur);
            cur = NULL;
        }
        else
        {
            del = (*BStree)->_pright;
            while (del->_pleft) 
            {
                del = del->_pleft;
            }
            (*BStree)->_data = del->_data;
            return DeleteBSTree(&(*BStree)->_pright, del->_data);
        }
    }
    return 1;
}