强撸AVL（C++实现

勉强算CLRS的课后题，就贴在这了

想不到勉强看懂了算法导论红黑树代码和证明后撸个AVL看别人的代码（有错）都要撸6小时（算上简单的调试），贴代码，不想解释原理，欢迎怼错=

AvlTree.h

#pragma once
#include <algorithm>
#include <iostream>
//智能指针了解一下，这样就不用自己去delete了
template<class T>
struct Atnode {
    Atnode(T value, int height, Atnode* l, Atnode* r) :
        key(value), height(height), left(l), right(r){}

    T key;
    int height;
    Atnode* left;
    Atnode* right;
};

template<class T>
class AvlTree {
    friend void print(AvlTree<T>* tree)//非成员函数不能加const修饰符
    {
        if (tree->Root)tree->_print(tree->Root);
    }
public:
    AvlTree():Root(nullptr){}
    ~AvlTree() { destroy(); }

    void inorder()const;

    void destroy() { destroy(Root); }

    void insert(T key) { Root = insert(Root, key); }
    void remove(T key) { Root = remove(Root, key); }

    int height()const { return height(Root); }

private:
    Atnode<T>* Root;

private:
    void _print(Atnode<T>* );
    //void inorder(Atnode<T>*)const;
    void destroy(Atnode<T>*);
    
    Atnode<T>* insert(Atnode<T>*, T key);
    Atnode<T>* remove(Atnode<T>*, T key);

    Atnode<T>* maxmimun(Atnode<T>*);
    Atnode<T>* minimum(Atnode<T>*);
    
    Atnode<T>* leftrotate(Atnode<T>*);
    Atnode<T>* left_right(Atnode<T>*);
    Atnode<T>* rightrotate(Atnode<T>*);
    Atnode<T>* right_left(Atnode<T>*);
    //记得考虑空结点
    int height(Atnode<T>*)const;
};
template<class T>
void AvlTree<T>::_print(Atnode<T>* root) {
    if (root->left != 0) {
        cout << root->left->key << "是" << root->key << "的左孩子" << endl;
        _print(root->left);
    }
    if (root->right != 0) {
        cout << root->right->key << "是" << root->key << "的右孩子" << endl;
        _print(root->right);
    }
}

template<class T>
Atnode<T>* AvlTree<T>::insert(Atnode<T>* root, T key) {
    if (root == nullptr) {//进行插入
        root = new Atnode<T>(key, 0, 0, 0);
        return root;
    }

    if (root->key == key) {//插入失败
        std::cerr << "已存在该节点，默认不进行操作" << endl;
        return root;
    }

    if (root->key > key) {//递归插入左子树
        root->left = insert(root->left, key);
        if (height(root->left) - height(root->right) == 2) {
            if (height(root->left->right) > height(root->left->left))
                root = left_right(root);
            else
                root = rightrotate(root);
        }
    }
    else{
        root->right = insert(root->right, key);
        if (height(root->right) - height(root->left) == 2) {
            if (height(root->right->left) > height(root->right->right))
                root = right_left(root);
            else
                root = leftrotate(root);
        }
    }
    root->height = max(height(root->left), height(root->right)) + 1;
    return root;
}

template<class T>
void AvlTree<T>::destroy(Atnode<T>* root) {
    if (root == nullptr)return;
    destroy(root->left);
    destroy(root->right);
    delete root;
}

template<class T>
Atnode<T>* AvlTree<T>::right_left(Atnode<T>* root) {
    root->right = rightrotate(root->right);
    return leftrotate(root);
}

template<class T>
Atnode<T>* AvlTree<T>::left_right(Atnode<T>* root) {
    root->left = leftrotate(root->left);
    return rightrotate(root);
}

template<class T>
Atnode<T>* AvlTree<T>::leftrotate(Atnode<T>* root) {
    Atnode<T>* rc = root->right;
    root->right = rc->left;
    rc->left = root;
    root->height = std::max(height(root->left), height(root->right)) + 1;
    rc->height = std::max(root->height, height(rc->right)) + 1;

    return rc;
}

template<class T>
Atnode<T>* AvlTree<T>::rightrotate(Atnode<T>* root) {
    Atnode<T>* lc = root->left;
    root->left = lc->right;
    lc->right = root;
    //更新原根和新根的高度
    root->height = std::max(height(root->left), height(root->right)) + 1;
    lc->height = std::max(height(lc->left), root->height) + 1;

    return lc;
}

template<class T>
Atnode<T>* AvlTree<T>::minimum(Atnode<T>*root) {
    if (root == nullptr)return 0;
    while (root->left)root = root->left;
    return root;
}

template<class T>
Atnode<T>* AvlTree<T>::maxmimun(Atnode<T>* root) {
    if (root == nullptr)return 0;
    while (root->right)root = root->right;
    return root;
}


template<class T>
inline
int AvlTree<T>::height(Atnode<T>* n)const {
    if (n == nullptr)return -1;
    else return n->height;
}

template<class T>
Atnode<T>* AvlTree<T>::remove(Atnode<T>* root, T key) {
    if (root == 0) {
        std::cerr << "兄弟，没得删" << endl;
        return nullptr;
    }

    //删除节点在左子树
    if (key < root->key) {
        root->left = remove(root->left, key);

        //在左子树删除后可能导致右子树高度过高，相当于在右子树插入新节点
        if (height(root->right) - height(root->left) == 2) {
            if (height(root->right->right) < height(root->right->left))
                root = right_left(root);
            else//else分支实际上包括两种情况
                root = leftrotate(root);
        }
    }
    //删除节点在右子树
    else if (key > root->key) {//调用旋转函数记得巴返回值赋给原来的root
        root->right = remove(root->right, key);//删除后拼接

        if (height(root->left) - height(root->right) == 2) {
            if (height(root->left->right) > height(root->left->left))
                root = left_right(root);
            else
                root = rightrotate(root);
        }
    }
    else {//找到删除节点
        if (root->left == 0) { 
            auto deleted = root;
            root = root->right;
            delete deleted;
        }
        else if (root->right == 0) { 
            auto deleted = root;
            root = root->left;
            delete deleted;
        }
        else {//均不为空，寻找替代root的点，
            //可以说左子树的max,也可以是右子树的min
            auto replace = root;
            //在左子树找替代点
            if (height(root->right) < height(root->left)) {
                replace = maxmimun(root->left);

                if (replace == root->left) {
                    auto deleted = root;
                    root->left->right = root->right;
                    root = root->left;
                    delete deleted;
                }
                else {
                    root->key = replace->key;
                    root->left = remove(root->left, replace->key);
                }
            }
            else {//在右子树寻找替代点
                replace = minimum(root->right);
                if (replace == root->right) {
                    auto deleted = root;
                    root->right->left = root->left;
                    root = root->right;
                    delete deleted;
                }
                else {
                    root->key = replace->key;
                    root->right = remove(root->right, replace->key);
                }
            }
        }
        //return root;
    }//切记更新高度，由于递归，自底向上更新，美妙
    if(root)//当节点为NULL时不要更新--
        root->height = max(height(root->left), height(root->right)) + 1;
    return root;
}

AvlTreeTest.cpp

#include "AvlTree.h"

#include <iostream>

using namespace std;

int main(void) {
    AvlTree<int> xixi;
    xixi.insert(3);
    xixi.insert(2);
    //xixi.insert(6);
    //xixi.insert(4);
    xixi.insert(5);
    xixi.insert(4);

    print(&xixi);
    xixi.remove(2);
    print(&xixi);

    return 0;
}

只做了几组简单的测试，发现的小问题都改了，当然可能还有错，望告知，虚心接受批评（逃