原理：用一个栈把插入和删除时搜索路径记录下来，按照一般二叉树执行了插入，删除操作后再原路返回，修改高度信息和进行旋转操作使满足AVL平衡条件。

//AVL树模板（部分）
#ifndef AVLTree_h
#define AVLTree_h
#include <iostream>
#include <stack>  //记录删除时遍历路径
template<typename Comparable>
class AVLTree
{
private:
    struct AvlNode //树结点的定义
    {
    	Comparable element;
        AvlNode *left;
        AvlNode *right;
        int height;
        AvlNode(const Comparable &theElement,AvlNode *lt=NULL,AvlNode *rt=NULL,int h=0)
            :element(theElement),left(lt),right(rt),height(h){}
    };
         AvlNode *root; //根节点的声明
    inline int max(int a,int b)  //计算两整数最大值，在算树高度时总是用到
    {
        if(a>b)return a;
        else return b;
    }
    inline int height(AvlNode *t)const  //计算高度
          {
        return NULL==t ? -1 :t->height;
    }
    void adjust(AvlNode *&t)  //调整使符合AVL条件
    {
                  if(height(t->left)-height(t->right)==2)
                if(height(t->left->right)<height(t->left->left))
                    rotateWithLeftChild(t);
                else 
                    doubleWithLeftChild(t);
        else if(height(t->right)-height(t->left)==2)
                if(height(t->right->left)<height(t->right->right))
                    rotateWithRightChild(t);
                else 
                    doubleWithRightChild(t);

    }
    bool insert(const Comparable &x,AvlNode *&t) //插入元素，非递归
    {
        stack<AvlNode**> searchp;
        AvlNode **iter=&t;
        while((*iter)!=NULL)
        {
            searchp.push(iter);
            if(x<(*iter)->element) iter=&(*iter)->left;
            else if((*iter)->element<x) iter=&(*iter)->right;
            else return false;  //重复
        }
        *iter=new AvlNode(x);
        while(!searchp.empty())  //开始回溯
        {
            AvlNode** backp=searchp.top();
            searchp.pop();
            (*backp)->height=max(height((*backp)->left),height((*backp)->right))+1;
            adjust(*backp);
        }
        return true;
    }
    bool remove(const Comparable &x,AvlNode *&t)  //移除元素，非递归
    {
        stack<AvlNode**> searchp;
        AvlNode **iter=&t;
        while(*iter!=NULL)
        {
            searchp.push(iter);
            if(x<(*iter)->element) iter=&((*iter)->left);
                else if((*iter)->element<x) iter=&((*iter)->right);
                else
                {
                    if((*iter)->left!=NULL&&(*iter)->right!=NULL) //Two child
                    {
                        AvlNode **oldit=iter;
                        iter=&((*iter)->right);
                        searchp.push(iter);
                        while((*iter)->left!=NULL)
                        {
                            iter=&((*iter)->left);  //查找要删除的结点按中序遍历后一个结点
                            searchp.push(iter);
                        }
                        (*oldit)->element=(*iter)->element;
                    }
                    *iter=((*iter)->left!=NULL)?(*iter)->left:(*iter)->right;
                    delete *(searchp.top());
                    searchp.pop();
                    while(!searchp.empty())  //开始回溯
                    {
                        AvlNode** backp=searchp.top();
                        searchp.pop();
                        (*backp)->height=max(height((*backp)->left),height((*backp)->right))+1;
                        adjust(*backp);
                    }
                    return true;
                }
        }
        return false;
    }
    void rotateWithRightChild(AvlNode *& k1) //单旋转
    {
        AvlNode *k2=k1->right;
        k1->right=k2->left;
        k2->left=k1;
        k1->height=max(height(k1->left),height(k1->right))+1;
        k2->height=max(height(k2->right),k1->height)+1;
        k1=k2;
    }
    void rotateWithLeftChild(AvlNode *& k2)  //单旋转II
    {
        AvlNode *k1=k2->left;
        k2->left=k1->right;
        k1->right=k2;
        k2->height=max(height(k2->left),height(k2->right))+1;
        k1->height=max(height(k2->left),k2->height)+1;
        k2=k1;
    }
    void doubleWithLeftChild(AvlNode *& k3)  //双旋转
    {
        rotateWithRightChild(k3->left);
        rotateWithLeftChild(k3);
    }
    void doubleWithRightChild(AvlNode *& k4)  //双旋转II
    {
        rotateWithLeftChild(k4->left);
        rotateWithRightChild(k4);
    }
//…………
}