AVL-TREE

#include <iostream>
#include <stdio.h>
using namespace std;
typedef int keyType;
struct BinaryTreeNode {
    keyType key;
    int height; //记录以该节点为root的树高度
    BinaryTreeNode* left; // left child
    BinaryTreeNode* right; // right child
};
// define AVL node
typedef BinaryTreeNode avlnode;
// define AVL tree
typedef BinaryTreeNode avltree;
// 比较左右子树高度，取最大的
int maxh(int ha, int hb) {
  return ha > hb ? ha : hb;
}
// 计算树的高度
int height(avltree* tree) {
    if (NULL == tree) return 0;
    return tree->height;
}
// single right rotate for LL model
avlnode* singleRightRotate(avlnode* aNode) {
  avlnode* bNode = aNode->left;
  // rebuild relation
  aNode->left = bNode->right;
  bNode->right = aNode;
  // adjust the height
  aNode->height = maxh(height(aNode->right), height(aNode->left)) + 1;
  bNode->height = maxh(height(bNode->right), height(bNode->left)) + 1;
  return bNode;
}
// single left rotate for RR model
avlnode* singleLeftRotate(avlnode* aNode) {
  avlnode* bNode = aNode->right;
  // rebuild relation
  aNode->right = bNode->left;
  bNode->left = aNode;
  // adjust height
  aNode->height = maxh(height(aNode->right), height(aNode->left)) + 1;
  bNode->height = maxh(height(bNode->right), height(bNode->left)) + 1;
  return bNode;
}
// double rotate for LR model
// left rotate first and then right rotate
avlnode* leftRightRotate(avlnode* aNode) {
  aNode->left = singleLeftRotate(aNode->left);
  return singleRightRotate(aNode);
}
// double rotate for RL model
// right rotate first and then left rotate
avlnode* rightLeftRotate(avlnode* aNode) {
  aNode->right = singleRightRotate(aNode->right);
  return singleLeftRotate(aNode);
}
// insert a key to AVL tree.
avlnode* avl_inssert(avltree* &tree, keyType key) {
  if(NULL == tree) {
    tree = (avlnode*) malloc(sizeof(avlnode));
    tree->key = key;
    tree->height = 1;
    tree->left = tree->right = NULL;
        }else if(key > tree->key) { // insert into the right subtree
         tree->right = avl_inssert(tree->right, key);
         int balanceFactor = height(tree->right) - height(tree->left);
         if(balanceFactor == 2) {
             if(key > tree->right->key) { // RR 型 , 右侧单旋
                  tree = singleLeftRotate(tree);
                  }else{ // RL型 , 右侧双旋
                    tree = rightLeftRotate(tree);
         }
            }
        }else if(key < tree->key) { // insert into the left subtree
          tree->left = avl_inssert(tree->left, key);
            int balanceFactor = height(tree->left) - height(tree->right);
            if(balanceFactor == 2) {
                                  if(key < tree->left->key) { // LL型 , 左侧单旋
                                            tree = singleRightRotate(tree);
                        }else{ // LR型 ， 左侧双旋
                 tree = rightLeftRotate(tree);
               }
        }
        } else { // if the key is already exists, nothing to do....
      }
  // 重新计算树的高度
  tree->height = maxh(height(tree->left), height(tree->right)) + 1;
  return tree;
}

// delete the given key from AVL tree.
avlnode* avl_delete(avltree* &tree, keyType key) {
    if (NULL == tree) {
        return NULL;
    }
    // delete the node with the given key
    if (key > tree->key) { // key exists in the right subtree
        tree->right = avl_delete(tree->right, key);
    } else if (key < tree->key) { // key exists in the left subtree
        tree->left = avl_delete(tree->left, key);
    } else {
        if (NULL != tree->left) { // when left is not NULL
            // find max node if left tree
            avlnode* dn = NULL;

            for (dn = tree->left; NULL != dn->right; dn = dn->right) {
            }
            // change the value
            tree->key = dn->key;
            // delete the max node
            tree->left = avl_delete(tree->left, dn->key);
        } else if (NULL != tree->right) { // when the right tree is not NULL
            // find the minimal node
            avlnode* dn = NULL;
            for (dn = tree->right; NULL != dn->left; dn = dn->left) {
            }
            // change the value
            tree->key = dn->key;
            // delete the minimal node
            tree->right = avl_delete(tree->right, dn->key);
        } else {            // when the node has no child
            free(tree);
            // the tree is Empty now, no need to do any operation
            return NULL;
        }
    }
    // adjust the tree to balance state after deletion
    if (height(tree->left) - height(tree->right) == 2) { // when the left subtree is too high
        if (height(tree->left->right) - height(tree->left->left) == 1) { // LR model
            tree = leftRightRotate(tree);
        } else { // LL model:
            tree = singleRightRotate(tree);
        }
    } else if (height(tree->left) - height(tree->right) == -2) { // when the right subtree is too high
        if (height(tree->right->left) - height(tree->right->right) == 1) { // RL model
            tree = rightLeftRotate(tree);
        } else { // RR model
            tree = singleLeftRotate(tree);
        }
    } else {
        // the tree is already balanced, nothing to do ...
    }

    // recalculate the height of the tree.
    tree->height = maxh(height(tree->right), height(tree->left)) + 1;

    return tree;
}

int main(){

}