AVL平衡二叉树C++版

#include <iostream>
using namespace std;

class AVLNode{
public:
    int data;
    int height;//结点的高度，叶子结点高度为1 
    AVLNode* lChild;
    AVLNode* rChild;
public:
    AVLNode(int data):data(data),height(1),lChild(0),rChild(0){} 
};

class AVL{
public:
    AVLNode* root;
public:
    AVL(){
        root = nullptr;
    }
    ~AVL(){
        delete root;
    }
    int height(AVLNode* root){
        if(root){
            return root->height;
        }
        return 0;
    } 
    //找到树中最大结点并将其返回 
    AVLNode* finMaxNode(AVLNode* root){
        //一直往右找 
        if(root->rChild){
            root = root->rChild;
        } 
        return root;
    }
    //找到树中最小结点并将其返回 
    AVLNode* finMinNode(AVLNode* root){
        //一直往左找 
        if(root->lChild){
            root = root->lChild;
        } 
        return root;
    }
    //以p为根结点右旋转，返回新的根结点 
    AVLNode* llRotate(AVLNode* p){
        AVLNode* pleft = p->lChild;
        p->lChild = pleft->rChild;
        pleft->rChild = p;  
        //结点的高度由该节点的子树唯一决定，所以只有子树发生变化的结点才需要更新高度值 
        pleft->height = max(height(pleft->lChild), height(pleft->rChild))+1;
        p->height = max(height(p->lChild), height(p->rChild))+1;
        return pleft; 
    }
    //左旋转 
    AVLNode* rrRotate(AVLNode* p){
        AVLNode* pright = p->rChild;
        p->rChild = pright->lChild;
        pright->lChild = p; 
        pright->height = max(height(pright->lChild), height(pright->rChild))+1;
        p->height = max(height(p->lChild), height(p->rChild))+1;
        return pright; 
    }
    //先左，再右 
    AVLNode* lrRotate(AVLNode* p){
        AVLNode* pleft = rrRotate(p->lChild);
        return llRotate(p);
    }
    //先右，再左 
    AVLNode* rlRotate(AVLNode* p){
        AVLNode* pright = llRotate(p->rChild);
        return rrRotate(p);
    }
    //插入新结点，保持平衡 
    void insert(int data, AVLNode*& root){
        if(!root){ 
            root = new AVLNode(data);
        }
        else{
            if(data < root->data){
                insert(data, root->lChild);
                //插入新结点后，如果打破平衡，则需要动态调整 
                if(height(root->lChild)-height(root->rChild) == 2){
                    if(data < root->lChild->data)
                        root = llRotate(root);
                    else
                        root = lrRotate(root);
                }
            }
            else if(data > root->data){
                insert(data, root->rChild);
                //插入新结点后，如果打破平衡，则需要动态调整 
                if(height(root->rChild)-height(root->lChild) == 2){
                    if(data > root->rChild->data)
                        root = rrRotate(root);
                    else
                        root = rlRotate(root);
                }
            }
            else{
                cout << "AVL中已存在该值:" << data << endl;
            }
        }
        //平衡后，需要更新根结点的高度值
        root->height = max(height(root->lChild), height(root->rChild))+1;
    }
    //删除结点，保持平衡 
    void del(int data, AVLNode*& root){
        if(data < root->data){
            del(data, root->lChild);
            //删除点之后，若AVL树失去平衡，则进行调整
            if(height(root->rChild)-height(root->lChild) == 2){
                AVLNode* r = root->rChild;
                if(height(r->lChild) > height(r->rChild))
                    root = rlRotate(root);
                else
                    root = rrRotate(root);
            } 
        }
        else if(data > root->data){
            del(data, root->rChild);
            //删除点之后，若AVL树失去平衡，则进行调整
            if(height(root->lChild)-height(root->rChild) == 2){
                AVLNode* l = root->lChild;
                if(height(l->lChild) > height(l->rChild))
                    root = llRotate(root);
                else
                    root = lrRotate(root);
            }
        }
        else{
            //此时root为要删除的点 
            if(root->lChild && root->rChild){
                if(height(root->lChild) > height(root->rChild)){
                    // 如果root的左子树比右子树高；
                    // 则(01)找出root的左子树中的最大节点
                    //   (02)将该最大节点的值赋值给root。
                    //   (03)删除该最大节点。
                    // 这类似于用"root的左子树中最大节点"做"root"的替身；
                    // 采用这种方式的好处是：删除"tree的左子树中最大节点"之后，AVL树仍然是平衡的。
                    AVLNode* maxNode = finMaxNode(root->lChild);
                    root->data = maxNode->data;
                    del(maxNode->data, root->lChild);
                }
                else{
                    AVLNode* minNode = finMinNode(root->rChild);
                    root->data = minNode->data;
                    del(minNode->data, root->rChild);
                }
            }
            else{
                if(root->lChild){
                    root->data = root->lChild->data;
                    root->lChild = nullptr;
                }   
                else if(root->rChild){
                    root->data = root->rChild->data;
                    root->rChild = nullptr;
                }
                else{
                    root = nullptr;//参数是引用，所以此处修改了主函数中的root值 
                }
            }
        }
    }
    void inOrder(AVLNode* root){
        if(root){
            inOrder(root->lChild);
            cout << root->data << endl;
            inOrder(root->rChild);
        }
    }
};

int main(){
    AVL tree;
    tree.insert(5, tree.root);
    tree.insert(15, tree.root);
    tree.insert(25, tree.root);
    tree.insert(35, tree.root);
    tree.insert(45, tree.root);
    tree.insert(55, tree.root);
    tree.del(55, tree.root);
    tree.inOrder(tree.root);
    return 0;
}