AVL Tree implemention

 头文件：
#ifndef AVLTREE_H
#define AVLTREE_H

template <class T>
class AVLTree;

template <class T>
class AVLTreeNode
{
 public:
  AVLTreeNode(const T k, AVLTreeNode<T> *l = NULL, AVLTreeNode<T> *r = NULL, int b = 0):/
   key(k), left(l), right(r), height(b) { }
  T keyValue()
  {
   return key;
  }
  friend class AVLTree<T>;
 private:
  AVLTreeNode *left;
  AVLTreeNode *right;
  T key;
  int height;
};

template <class T>
class AVLTree
{
 public:
  AVLTree(AVLTreeNode<T> *r):root(r) {}
  AVLTree(T key):root(new AVLTreeNode<T>(key)){ }
  AVLTree<T>& insert(const T key);
  AVLTree<T>& deleteNode(const T key);
  void inOrder(void (*visit)(AVLTreeNode<T> *node))
  {
   inOrder(visit, root);
  }
  int height(AVLTreeNode<T> *t);
 private:
  AVLTreeNode<T> *root;
  AVLTreeNode<T> *singleRotateWithLeft(AVLTreeNode<T> *p);
  AVLTreeNode<T> *singleRotateWithRight(AVLTreeNode<T> *p);
  AVLTreeNode<T> *doubleRotateWithLeft(AVLTreeNode<T> *p);
  AVLTreeNode<T> *doubleRotateWithRight(AVLTreeNode<T> *p);
  AVLTreeNode<T> *updateTreeLeft(AVLTreeNode<T> *p);
  AVLTreeNode<T> *updateTreeRight(AVLTreeNode<T> *p);
  AVLTreeNode<T> *insert(const T key, AVLTreeNode<T> *tree);
  void inOrder(void (*visit)(AVLTreeNode<T> *node), AVLTreeNode<T> *t);
};

#include "AVLTree.cpp"

#endif

//"AVLTree.cpp"

 

template <class T>
AVLTreeNode<T>* AVLTree<T>::singleRotateWithLeft(AVLTreeNode<T> *p)
{
 AVLTreeNode<T> *lc = p->left;
 p->left = lc->right;
 lc->right = p;
 return lc;
}

template <class T>
AVLTreeNode<T>* AVLTree<T>::singleRotateWithRight(AVLTreeNode<T> *p)
{
 AVLTreeNode<T> *rc = p->right;
 p->right = rc->left;
 rc->left = p;
 return rc;
}

template <class T>
AVLTreeNode<T>* AVLTree<T>::doubleRotateWithLeft(AVLTreeNode<T> *p)
{
 AVLTreeNode<T> *lc = p->left;
 p->left = singleRotateWithRight(lc);
 return singleRotateWithLeft(p);
} 

template <class T>
AVLTreeNode<T>* AVLTree<T>::doubleRotateWithRight(AVLTreeNode<T> *p)
{
 AVLTreeNode<T> *rc = p->right;
 p->right = singleRotateWithLeft(rc);
 return singleRotateWithRight(p);
}

template <class T>
AVLTreeNode<T>* AVLTree<T>::insert(const T key, AVLTreeNode<T> *tree)
{
 if (NULL == tree)
 {
  AVLTreeNode<T> *newNode = new AVLTreeNode<T>(key);
  tree = newNode;
 }
 else if (key < tree->key)
 {
  tree->left = insert(key, tree->left);
  if (height(tree->left)-height(tree->right) == 2)
  {
   if (key < tree->left->key)
    tree = singleRotateWithLeft(tree);
   else
    tree = doubleRotateWithLeft(tree);
  }
 }
 else if (key > tree->key)
 {
  tree->right = insert(key, tree->right);
  if (height(tree->left)-height(tree->right) == -2)
  {
   if (key > tree->right->key)
    tree = singleRotateWithRight(tree);
   else
    tree = doubleRotateWithRight(tree);
  }
 }
 tree->height = height(tree);
 return tree;
}

template <class T>
int AVLTree<T>::height(AVLTreeNode<T> *t)
{
 if(!t)
  return 0;
 else
  return 1 + max(height(t->left), height(t->right));
}

template <class T>
AVLTree<T>& AVLTree<T>::insert(const T key)
{
 int reviseFactor = 0;
 root = insert(key, root);
 return *this;
}

template <class T>
void AVLTree<T>::inOrder(void (*visit)(AVLTreeNode<T> *node), /
       AVLTreeNode<T> *t)
{
 if(t)
 {
  inOrder(visit, t->left);
  visit(t);
  inOrder(visit, t->right);
 }
}