前面我们写了AVL树的创建AVL树插入节点，即节点的插入，下面我们介绍AVL树节点的删除，与前面调整的 方法相同，在树不平衡时，对树进行调整，具体步骤如下：

1.
– 判断树是否为NULL，若为NULL，直接返回false;
– 判断树是否只有一个节点，且该节点为要删除的节点，直接删除，_pRoot置NULL；
– 否则的话找到要删除节点的位值，删除该节点（分三种情况），并用其孩子节点来代替要删除的节点，该过程树可能出现不平衡，需要调整；

2.删除节点：
– 当要删除的节点只有左孩子；
– 要删除的节点只有右孩子；
– 要删除的节点左右孩子都存在，此时中序遍历其右子树的第一个节点，替换并删除；

3.删除后更新平衡因子，判断树是否平衡并做相应的旋转处理

代码实现：

    bool _Remove(const k& key,const v& value)
    {
        if(_pRoot == NULL)
            return false;
        if(_pRoot->_pLeft == NULL && _pRoot->_pRight == NULL && _pRoot->_key == key)
        {
            delete _pRoot;
            _pRoot = NULL;
        }

        //查找要删除的位置
        Node* pNode = _pRoot;
        Node* pParent = NULL;

        while(pNode)
        {
            if(pNode->_key > key)
            {
                pParent = pNode;
                pNode = pNode->_pLeft;
            }
            else if(pNode->_key < key)
            {
                pParent = pNode;
                pNode = pNode->_pRight;
            }
            else
                break;
        }
        //已找到要删除的节点
        Node* pDel = NULL;

        if(pNode)
        {
            if(pNode->_pLeft == NULL)//只有右子树存在
            {
                if(_pRoot->_key == pNode->_key)
                {
                    pDel = pNode;
                    _pRoot = pNode->_pRight;
                    delete pDel;
                    //删除根节点不需要调整
                    return true;
                }
                else
                {
                    if(pParent->_pLeft == pNode)
                    {
                        pDel = pNode;
                        pParent->_pLeft = pNode->_pRight;
                        pNode = pParent->_pLeft;
                        //更新平衡因子
                        //pParent->_bf++;
                    }
                    else
                    {
                        pDel = pNode;
                        pParent->_pRight = pNode->_pRight;
                        pNode = pParent->_pRight;
                    }
                }
            }
            else if(pNode->_pRight == NULL)//只有左子树
            {
                if(_pRoot == pNode)
                {
                    pDel = pNode;
                    _pRoot = pNode->_pLeft;
                    delete pDel;
                    //删除根节点不需要调整
                    return true;
                }
                else
                {
                    if(pParent->_pLeft = pNode)
                    {
                        pDel = pNode;
                        pParent->_pLeft = pNode->_pLeft;
                        pNode = pParent->_pLeft;
                    }
                    else
                    {
                        pDel = pNode;
                        pParent->_pRight = pNode->_pLeft;
                        pNode = pParent->_pRight;
                    }
                }
            }
            else //左右子树都存在
            {
                Node* pCur = pNode;
                while(pCur->_pLeft)
                {
                    pParent = pCur;
                    pCur = pCur->_pLeft;//找到中序遍历的第一个节点
                }

                pNode->_key = pCur->_key;
                pNode->_value = pCur->_value;


                pDel = pCur;//????

                pParent->_pLeft = pCur->_pRight;
                pNode = pParent->_pLeft;

            }
            delete pDel;
        }


        //删除了节点pDel，更新平衡因子
        while(pParent)
        {
            if(pParent->_pLeft == pNode)//删除的是左孩子
                pParent->_bf++;
            else if(pParent->_pRight == pNode)//删除的是右孩子
                pParent->_bf--;
            if(pParent->_bf == 1 || pParent->_bf == -1)//pParent左右孩子都存在，删除节点不影响他的高度
                return true;
            else if(pParent->_bf == 0)
            {
                //if(pParent->_pLeft == pDel)//pParent存在左孩子
                //{}
                pNode = pParent;
                pParent = pParent->_pParent;
            }
            else
            {
                //不满足平衡树，要做旋转处理
                if(pParent->_bf == 2)//右子树
                {
                    if(pNode==NULL ||pNode->_bf == 1)//右侧
                        _RotateL(pParent);//左旋调整
                    else//左侧
                        _RotateRL(pParent);//先右旋再左旋
                }
                else//左子树
                {
                    if(pNode==NULL || pNode->_bf == -1)//左侧
                        _RotateR(pParent);
                    else//右侧
                        _RotateLR(pParent);
                }
                break;//调整完后跳出循环
            }   
        }
    }

旋转处理见上篇博客，AVL的创建，这里不加赘述；