AVL平衡二叉树

#include <iostream>
#include <cmath>
#include <algorithm>
#include <time.h>

using namespace std;

#define DEFAULTVALUE (-1)

struct avlNode {
    int height;
    int value;
    avlNode* left;
    avlNode* right;
    avlNode(int v = DEFAULTVALUE, avlNode* l = NULL, avlNode* r = NULL, int h = 0):value(v), left(l), right(r), height(h) {}
};

int getHegiht(avlNode* root) {
    return root == NULL ? -1 : root->height;
};

class AvlTree {
private:
    avlNode* root;
    //内部调用
    void insert(avlNode*& root, int value);
    //左右旋代表着节点的哪一边子树需要旋转
    void rotateLeft(avlNode*& root);
    void rotateRight(avlNode*& root);
    void doubleRotateLeft(avlNode*& root);
    void doubleRotateRight(avlNode*& root);
    void inOrder(avlNode* root);
    void preOrder(avlNode* root);
    void postOrder(avlNode* root);
public:
    //用户接口
    AvlTree();
    void insert(int value);
    void inOrder();
    void preOrder();
    void postOrder();
};
AvlTree::AvlTree() {
    root = NULL;
}

void AvlTree::insert(int value) {
    insert(root, value);
}

void AvlTree::insert(avlNode*& root, int value) {
    if (root == NULL) {
        root = new avlNode(value);
    }
    else if (root->value < value) {
        //若是在右边插入，则只有可能出现右子树高度比左子树大2的情况
        insert(root->right, value);
        if (getHegiht(root->right) - getHegiht(root->left) == 2) {
            //若出现高度不平衡，则判断不平衡的三个节点形成一条直线还是折线，
            //直线只需单旋，折线需要双旋
            if (root->right->value < value) {
                rotateRight(root);
            }
            else {
                doubleRotateRight(root);
            }
        }
    }
    else if (root->value > value) {
        //若是在左边插入，则只有可能出现左子树高度比右子树大2的情况
        insert(root->left, value);
        if (getHegiht(root->left) - getHegiht(root->right) == 2) {
            //若出现高度不平衡，则判断不平衡的三个节点形成一条直线还是折线，
            //直线只需单旋，折线需要双旋
            if (root->left->value > value) {
                rotateLeft(root);
            }
            else {
                doubleRotateLeft(root);
            }
        }
    }
    root->height = max(getHegiht(root->left), getHegiht(root->right)) + 1;
}

void AvlTree::rotateLeft(avlNode*& root) {
    avlNode* t2 = root->left;
    root->left = t2->right;
    t2->right = root;
    //更新高度，注意先更新root（即降下去的节点的高度）
    root->height = max(getHegiht(root->right), getHegiht(root->left)) + 1;
    t2->height = max(getHegiht(t2->right), getHegiht(t2->left)) + 1;
    root = t2;
}

void AvlTree::rotateRight(avlNode*& root) {
    avlNode* t2 = root->right;
    root->right = t2->left;
    t2->left = root;
    //更新高度
    root->height = max(getHegiht(root->right), getHegiht(root->left)) + 1;
    t2->height = max(getHegiht(t2->right), getHegiht(t2->left)) + 1;
    root = t2;
}

void AvlTree::doubleRotateLeft(avlNode*& root) {
    rotateRight(root->left);
    rotateLeft(root);
}

void AvlTree::doubleRotateRight(avlNode*& root) {
    rotateLeft(root->right);
    rotateRight(root);
}

void AvlTree::inOrder() {
    inOrder(root);
}
void AvlTree::preOrder() {
    preOrder(root);
}
void AvlTree::postOrder() {
    postOrder(root);
}

void AvlTree::inOrder(avlNode* root) {
    if (root == NULL)
        return;
    inOrder(root->left);
    cout << root->value << ' ';
    inOrder(root->right);
}

void AvlTree::preOrder(avlNode* root) {
    if (root == NULL)
        return;
    cout << root->value << ' ';
    inOrder(root->left);
    inOrder(root->right);
}

void AvlTree::postOrder(avlNode* root) {
    if (root == NULL)
        return;
    inOrder(root->left);
    inOrder(root->right);
    cout << root->value << ' ';
}