AVL树的代码（插入和删除算法）

#include<iostream>
#include<vector>
#include<stack>
using namespace std;
template<class type>
class AVL;
template<class type>
class AVLnode
{
public:
    friend class AVL<int>;
public:
    AVLnode(AVLnode<type>* L = nullptr, AVLnode<type>* R = nullptr,type n=type()):left(L),right(R),data(n),bf(0)
    {    }
    
private:
    AVLnode<type>* left;
    AVLnode<type>* right;
    type data;
    int bf;
};
template<class type>

class AVL
{
public:
    AVL(AVLnode<type>* tree=nullptr):t(tree)
    {}
    void ROTATEL( AVLnode<type>* &pr)
    {
        AVLnode<type>* p = pr->right;pr->right = p->left;
        p->left = pr;
        
        pr->bf = 0;
        p->bf = 0;
        pr = p;
    }//左旋转
    void ROTATERL(AVLnode<type>*& pr)
    {
        AVLnode<type>* p = pr->right;
        pr->right = p->left;
        p->left = nullptr;
        pr->right->right = p;
        p->bf = 0;
        pr->bf = 2;
        ROTATEL(pr);
    }//先右后左旋转
    void ROTATER(AVLnode<type>*& pr)
    {
        AVLnode<type>* p = pr->left;
        pr->left = p->right;
        p->right = pr;
        pr->bf = 0;
        p->bf = 0;
        pr = p;

    }//右旋转
    void ROTATELR(AVLnode<type>*& pr)
    {
        AVLnode<type>* p = pr->left;
        pr->left = p->right;
        p->right = nullptr;
        pr->left->left = p;
        p->bf = 0;
        pr->left->bf = -1;
        pr->bf = -2;
        ROTATER(pr);
    }//左右旋转
    //删除节点
    void pop(type num)
    {
        AVLnode<type>* p = t;
        stack<AVLnode<type>*> st;

        while (p->data != num)
        {
            st.push(p);
            if (p->data > num)
                p = p->left;
            else
                p = p->right;
        }//找到要删除的节点
        AVLnode<type>* q, * p1;
        if (p->left != nullptr && p->right != nullptr)
        {
            p1 = p;
            q = p->left;
            st.push(p);
            while (q->right != nullptr)
            {
                st.push(q);
                q = q->right;
            }
            p->data = q->data;
            p = q;
        }//bst的规则删除节点
        AVLnode<type>* pr = st.top();
        
        if (p->left!=nullptr)
            q = p->left;
        else
            q = p->right;
        if (pr == nullptr)
            t = q;
        else if (pr->left == p)
        {
            pr->left = q;
            pr->bf++;
        }
        else
        {
            pr->right = q;
            pr->bf--;
        }
        int i = 0;
        //调整平衡
        while (!st.empty())
        {
            int flag = 0;
            pr = st.top();
            st.pop();
            if (p->data < pr->data&&i>0)
                pr->bf++;
            else if(p->data>pr->data&&i>0)
                pr->bf--;
            if (pr->bf == 1||pr->bf==-1)
                break;
            if (pr->bf == 0)
                q = pr;
            else
            {
                if (pr->bf > 0)
                    q = pr->right;
                else
                    q = pr->left;
                if (q->bf == 0)
                {
                    if (pr->left == q)
                    {
                        ROTATER(pr);
                        pr->bf = 1;
                        pr->right->bf = -1;
                    }
                    else
                    {
                        ROTATEL(pr);
                        pr->bf = 1;
                        pr->left->bf = -1;
                    }
                    flag = 1;
                }
                else
                {
                    if (pr->bf > 0 && q->bf > 0)
                        ROTATEL(pr);
                    else if (pr->bf < 0 && q->bf < 0)
                        ROTATER(pr);
                    else if (pr->bf > 0 && q->bf < 0)
                        ROTATERL(pr);
                    else if (pr->bf < 0 && q->bf>0)
                        ROTATELR(pr);
                    q = pr;
                }
            }
            if (st.empty())
                t = pr;
            else
            {
                AVLnode<type>* ppr = st.top();
                if (pr->data > ppr->data)
                {
                    ppr->right = pr;
                }
                else
                    ppr->left = pr;
            }
            if (flag == 1)
                break;
            i++;
        }

    }
    void insert(type num)
    {
        //插入节点
        stack<AVLnode<type>*> st;
        AVLnode<type>* p = t;
        AVLnode<type>* pr=nullptr;
        AVLnode<type>* s = new AVLnode<type>;
        s->data = num;
        if (t == nullptr)
        {
            t = s;
            return;
        }
        while (p != nullptr)
        {
            pr = p;
            st.push(pr);
            if (num > p->data)
                p = p->right;
            else
                p = p->left;
        }
        if (num == pr->data)
            return;
        if (s->data > pr->data)
            pr->right = s;
        else
            pr->left = s;
        p = s;
        //保持平衡
        while (!st.empty())
        {
            pr = st.top();
            st.pop();
            if (p == pr->left)
                pr->bf--;
            else
                pr->bf++;
            if (pr->bf == 0)
                break;
            if (pr->bf ==1 || pr->bf == -1)
            {
                p = pr;
            }
            else
            {
                if (pr->bf > 0)
                {
                    if (p->bf > 0)
                        ROTATEL(pr);
                    else
                        ROTATERL(pr);    
                }
                if (pr->bf < 0)
                {
                    if (p->bf < 0)
                        ROTATER(pr);
                    else
                        ROTATELR(pr);
                }
                break;
            }

        }
        if (pr->left==t ||pr->right ==t)
            t = pr;
        if (!st.empty())
        {
            AVLnode<type>* ppr = st.top();
            if (ppr->data < pr->data)
                ppr->right = pr;
            else
                ppr->left = pr;
        }
        

    }
private:
    AVLnode<type>* t;
};