基本数据结构之AVL树

AVL树即自平衡二叉查找树。在AVL树中，任何两个结点的两个子树的高度最大差别为1，所以AVL树也被称为高度平衡树。

AVL树在插入和删除和查找的时间复杂度在平均和最坏情况下都是O(log N),插入和删除需要通过1次或者多次旋转重新使树达到平衡。

怎么判断AVL树是平衡的呢？需要通过平衡因子来来判断，结点的平衡因子是是它的左子树高度减去右子树高度.平衡因子为1、0、-1的结点是平衡的。反之，则是不平衡的。

几种旋转的情况：

1：RR旋转

  初始：     c

           /

         b

  现在插入一个元素a,如下图所示， 这时，AVL已经不平衡了，经过向右旋转-->         b         ,此时，树平衡了。

             c                                                                /   \

           /                                                                a       c

         b

       /

     a

2：LL 旋转

初始：   c

           \

             b

    现在插入一个元素a,如下图所示，这是AVL已经不平衡了，经过向左旋转-->         b         ,此时，树平衡了

        c                                                                    /   \

          \                                                                c       a

            b

             \

               a

3：LR旋转

初始：   c

       /

     b

在b的右子树插入结点,需要经过两次旋转，首先将a向左旋转，然后将c向右旋转：

        c                    c                   b

      /                    /                   /   \

     b     ----->        b      ---->        a      c

       \               /

         a           a

4:RL旋转

初始： c

        \

          b

在b的左子树插入结点a,首相将a向右旋转，然后将c向左旋转。

       c                 c                       b

         \                 \                   /   \

           b  ---->          b        --->   c      a

         /                     \

        a                        a

了解了以上四种旋转方式，在接下来的AVL树的插入或阐述操作中进行平衡操作时就更容易理解了。

下面具体讲解下AVL树的实现。

//////////////////////////////////////////////////////////////////////////////////////////

/* AVL with c implentation*/
typedef enum { LEFT = 0, RIGHT = 1 } direction_t;
#define MAX(a,b) ( (a) > (b) ? (a) : (b) )#define MIN(a,b) ( (a) < (b) ? (a) : (b) )
#define OTHER_DIR(x) direction_t( 1 - (x) )
typedef struct avl_node {  DATA_TYPE data;  short bal;  strutc avl_node *subtree[2];}AVLnode_t, *AVLtree_t;/* avl_node */
const AVLtree_t *AVLnull = ((AVLtree_t)NULL);
/* * rotate_once() -- rotate a given node in the given direction * to restore the balance of a tree */short rotate_once(AVLtree_t *rootp, direction_t dir){  direction_t other_dir = OTHER_DIR(dir); /* opposite of "dir" */  AVLtree_t old_root = *rootp; /* copy of original root */  short ht_unchanged; /* true if height unchanged */    /* Here we need to take into account the special case that occurs ** when a single rotation was made but the HEIGHT of the rotated ** tree did NOT change as a result of the rotation (we will need ** this later) */  ht_unchanged = ((*rootp)->subtree[other_dir]->bal) ? FALSE : TRUE;      /* assign new root */  *rootp = old_root->subtree[other_dir];      /* new-root exchanges it's "dir" subtree for it's parent */  old_root->subtree[other_dir] = (*rootp)->subtree[dir];  (*rootp)->subtree[dir] = old_root;      /* update balances */  old_root->bal = -(dir == LEFT ? --((*rootp)->bal) : ++((*rootp)->bal));     return ht_unchanged;  }/* rotate_once */
/* rotate_twice() -- rotate a given node in the given direction * and then in the opposite direction * to restore the balance of a tree */void rotate_twice(AVLtree *rootp, direction_t dir) {  direction_t other_dir = OTHER_DIR(dir);  AVLtree_t old_root = *rootp;  AVLtree_t old_other_dir_subtree = (*rootp)->subtree[other_dir];
      /* assign new root */  *rootp = old_root->subtree[other_dir]->subtree[dir];
      /* new-root exchanges it's "dir" subtree for it's grandparent */  old_root->subtree[other_dir] = (*rootp)->subtree[dir];  (*rootp)->subtree[dir] = old_root;
       /* new-root exchanges it's "other-dir" subtree for it's parent */  old_other_dir_subtree->subtree[dir] = (*rootp)->subtree[other_dir];  (*rootp)->subtree[other_dir] = old_other_dir_subtree;
        /* update balances */  (*rootp)->subtree[LEFT]->bal = -MAX((*rootp)->bal, 0);  (*rootp)->subtree[RIGHT]->bal = -MIN((*rootp)->bal, 0);  (*rootp)->bal = 0;
}/* rotate_twice */
 /* Balance Definitions */enum { LEFT_HEAVY = -1, BALANCED = 0, RIGHT_HEAVY = 1 };#define LEFT_IMBALANCE(nd) ( (nd)->bal < LEFT_HEAVY )#define RIGHT_IMBALANCE(nd) ( (nd)->bal > RIGHT_HEAVY )
 /* * balance() -- determines and performs the sequence of rotations needed * (if any) to restore the balance of a given tree. * * Returns 1 if tree height changed due to rotation; 0 otherwise */  short  balance(AVLtree_t *rootp) {      short special_case = FALSE;
      if (LEFT_IMBALANCE(*rootp)) { /* need a right rotation */        if ((*rootp)->subtree[LEFT]->bal == RIGHT_HEAVY) {            rotate_twice(rootp, RIGHT); /* double RL rotation needed */        } else { /* single RR rotation needed */            special_case = rotate_once(rootp, RIGHT);        }      } else if (RIGHT_IMBALANCE(*rootp)) { /* need a left rotation */        if ((*rootp)->subtree[RIGHT]->bal == LEFT_HEAVY) {            rotate_twice(rootp, LEFT); /* double LR rotation needed */        } else { /* single LL rotation needed */            special_case = rotate_once(rootp, LEFT);        }      } else {        return HEIGHT_UNCHANGED; /* no rotation occurred */      }
      return (special_case) ? HEIGHT_UNCHANGED : HEIGHT_CHANGED;  }/* balance */  /* * ckalloc(size) -- allocate space; check for success */  void *  ckalloc(unsigned size) {      void *ptr;
      if ((ptr = malloc(size)) == NULL) {        fprintf(stderr, "Unable to allocate storage.");        exit(1);      }/* if */
      return ptr;  }/* ckalloc */

 /* * new_node() -- get space for a new node and its data; * return the address of the new node */  AVLtree_t  new_node(void *data, unsigned size) {      AVLtree_t root;
      root = (AVLtree_t) ckalloc(sizeof(AVLnode));      root->data = (void *) ckalloc(size);      memmove(root->data, data, size);      root->bal = BALANCED;      root->subtree[LEFT] = root->subtree[RIGHT] = AVLnull;
      return root;  }/* new_node */

 /* * free_node() -- free space for a node and its data! * reset the node pointer to NULL */  void  free_node(AVLtree_t *rootp) {      free((void *) *rootp);      *rootp = AVLnull;  }/* free_node */

 /* * node_type() -- determine the number of null pointers for a given * node in an AVL tree, Returns a value of type node_t * which is an enumeration type with the following * values: * * IS_TREE -- both subtrees are non-empty * IS_LBRANCH -- left subtree is non-empty; right is empty * IS_RBRANCH -- right subtree is non-empty; left is empty * IS_LEAF -- both subtrees are empty * IS_NULL -- given tree is empty */    typedef enum { IS_TREE, IS_LBRANCH, IS_RBRANCH, IS_LEAF, IS_NULL } node_t;    node_t  node_type(AVLtree_t tree) {      if (tree == AVLnull) {        return IS_NULL;      } else if ((tree->subtree[LEFT] != AVLnull) &&                 (tree->subtree[RIGHT] != AVLnull)) {        return IS_TREE;      } else if (tree->subtree[LEFT] != AVLnull) {        return IS_LBRANCH;      } else if (tree->subtree[RIGHT] != AVLnull) {        return IS_RBRANCH;      } else {        return IS_LEAF;      }  }/* node_type */    /* * avl_min() -- comparator used to find the minimal element in a tree */      int      avl_min(void *el1, void *el2, node_t nd_typ) {          if ((nd_typ == IS_RBRANCH) || (nd_typ == IS_LEAF)) {            return 0; /* left subtree is empty -- this is the minimum */          } else {            return -1; /* keep going left */          }      }/* avl_min */

     /* * avl_max() -- comparator used to find the maximal element in a tree */      int      avl_max(void *el1, void *el2, node_t nd_typ) {          if ((nd_typ == IS_LBRANCH) || (nd_typ == IS_LEAF)) {            return 0; /* right subtree is empty -- this is the maximum */          } else {            return 1; /* keep going right */          }      }/* avl_max */             /* * avl_compare() -- compare an item with a node-item in an avl tree */      int      avl_compare(void *el1, void *el2, node_t nd_typ, int (*el_cmp)(...)) {         if ((el_cmp == avl_min) || (el_cmp == avl_max)) {           return (*el_cmp)(el1, el2, nd_typ);         } else {           return (*el_cmp)(el1, el2);         }      }/* avl_compare */

/* * avl_insert() -- insert an item into the given tree * * PARAMETERS: * data -- a pointer to a pointer to the data to add; * On exit, *data is NULL if insertion succeeded, * otherwise address of the duplicate key * rootp -- a pointer to an AVL tree * compar -- name of the function to compare 2 data items */      short      avl_insert(void **data, AVLtree_t *rootp, int (*el_cmp)(...)) {          short increase;          int cmp;
          if (*rootp == AVLnull) { /* insert new node here */            *rootp = new_node(*data, SIZE_OF_DATA);            *data = NULL; /* set return value in data */            return HEIGHT_CHANGED;          }/* if */
          cmp = (*el_cmp)(*data, (*rootp)->data); /* compare data items */
          if (cmp < 0) { /* insert into the left subtree */            increase = -avl_insert(data, &((*rootp)->subtree[LEFT]), el_cmp);            if (*data != NULL) return HEIGHT_UNCHANGED;          } else if (cmp > 0) { /* insert into the right subtree */            increase = avl_insert(data, &((*rootp)->subtree[RIGHT]), el_cmp);            if (*data != NULL) return HEIGHT_UNCHANGED;          } else { /* data already exists */            *data = (*rootp)->data; /* set return value in data */            return HEIGHT_UNCHANGED;          }
          (*rootp)->bal += increase; /* update balance factor */
        /********************************************************************** * re-balance if needed -- height of current tree increases only if its * subtree height increases and the current tree needs no rotation. **********************************************************************/          if (increase && (*rootp)->bal) {            return (1 - balance(rootp));          } else {            return HEIGHT_UNCHANGED;          }      }/* avl_insert */

/* * avl_delete() -- delete an item from the given tree * * PARAMETERS: * data -- a pointer to a pointer to the key to delete * On exit, *data points to the deleted data item * (or NULL if deletion failed). * rootp -- a pointer to an AVL tree * compar -- name of function to compare 2 data items */      short      avl_delete(void **data, AVLtree_t *rootp, int (*el_cmp)(...)) {          short decrease;          int cmp;          AVLtree_t old_root = *rootp;          node_t nd_typ = node_type(*rootp);          direction_t dir = (nd_typ == IS_LBRANCH) ? LEFT : RIGHT;
          if (*rootp == AVLnull) { /* data not found */            *data = NULL; /* set return value in data */            return HEIGHT_UNCHANGED;          }/* if */
             /* compare data items */                /* NOTE the extra parameter to compare this time */          cmp = el_cmp(*data, (*rootp)->data, nd_typ);
          if (cmp < 0) { /* delete from left subtree */            decrease = -avl_delete(data, &((*rootp)->subtree[LEFT]), el_cmp);            if (*data == NULL) return HEIGHT_UNCHANGED;          } else if (cmp > 0) { /* delete from right subtree */            decrease = avl_delete(data, &((*rootp)->subtree[RIGHT]), el_cmp);            if (*data == NULL) return HEIGHT_UNCHANGED;          } else {
        /********************************************************************** * At this point we know that if "cmp" is zero then "*rootp" points to * the node that we need to delete. There are three cases: * * 1) The node is a leaf. Remove it and return. * * 2) The node is a branch (has only 1 child). Make "*rootp" * (the pointer to this node) point to the child. * * 3) The node has two children. We swap data with the successor of * "*rootp" (the smallest item in its right subtree) and delete * the successor from the right subtree of "*rootp". The * identifier "decrease" should be reset if the subtree height * decreased due to the deletion of the successor of "rootp". **********************************************************************/
               /* cmp == 0 */            *data = (*rootp)->data; /* set return value in data */
            switch (nd_typ) { /* what kind of node are we removing? */               case IS_LEAF :                  free_node(rootp); /* free the leaf, its height */                  return HEIGHT_CHANGED; /* changes from 1 to 0, return 1 */
               case IS_RBRANCH : /* only child becomes new root */               case IS_LBRANCH :                  *rootp = (*rootp)->subtree[dir];                  free_node(&old_root); /* free the deleted node */                  return HEIGHT_CHANGED; /* just shortened "dir" subtree */
               case IS_TREE :                  decrease = avl_delete(&((*rootp)->data),                                        &((*rootp)->subtree[RIGHT]),                                        avl_min);            } /* switch */          } /* else */
          (*rootp)->bal -= decrease; /* update balance factor */
        /********************************************************************** * Rebalance if necessary -- the height of current tree changes if one * of two things happens: (1) a rotation was performed which changed * the height of the subtree (2) the subtree height decreased and now * matches the height of its other subtree (so the current tree now * has a zero balance when it previously did not). **********************************************************************/          if (decrease && (*rootp)->bal) { /* return 1 if height */            return balance(rootp); /* changed due to rotation */          } else if (decrease && !(*rootp)->bal) {                                              /* or if balance is 0 from */            return HEIGHT_CHANGED; /* height decrease of subtree */          } else {            return HEIGHT_UNCHANGED;          }      }/* avl_delete */

以上代码选自：libavl