二叉查找树系列六：AVL树

动态符号表可以用二叉查找树表示，最坏情况下，二叉查找树可完全偏斜，高度为n，其平均和最坏查找时间都是O(n)；最好情况下，二叉查找树的结点尽可能靠近根节点，其平均和最坏查找时间都是O(log2n)。因而，为了得到较好的查询效率，最理想的情况是时刻保持树是一棵完全二叉树，然而，为了达到这种要求就会使插入和删除的操作付出很高的代价。对此，人们设计出在高度上相对平衡的二叉查找树，其查找、插入和删除的时间都是O(log2n)。

AVL树是有Adelson-Velskii和Landis提出的，一种在高度上相对平衡的二叉查找树。由于该树的平衡性，其平均和最坏查找时间都是O(log2n)，且插入和删除也只需O(log2n)时间，插入和删除后的树仍是高度上相对平衡的。

（1）AVL树的定义

空二叉树是AVL树，如果T是一棵非空二叉查找树，其左子树为TL，右子树为TR，TL的高度为HL，TR的高度为HR，则T是AVL树当且仅当:

a. TL和TR是AVL树;

b. |HL-HR|<=1.

或者说：AVL树是每个结点的左右子树高度最多差1的二叉查找树。

由斐波那契数可以推出AVL树的高度最多为1.44log(N+2)-1.328，它只比logN多一点。

（2）AVL树的插入

当向AVL树中插入新的结点时，需要更新通向根结点路径上那些结点的所有平衡信息，此外，插入可能会破坏AVL树的平衡特性，通常需要在插入后通过修正来保持AVL树的特性，对此常用的方法是旋转。

假如插入新结点后结点A的两棵子树的高度差为2，那么可以推断插入应是下列四种情况中的一种：

LL：对A的左儿子的左子树进行一次插入

LR：对A的左儿子的右子树进行一次插入

RL：对A的右儿子的左子树进行一次插入

RR：对A的右儿子的右子树进行一次插入

上面的情形中LL和RR是对称的，LR和RL是对称的，对于前者，可以通过单旋转恢复AVL树的特性，对于后者可以通过双旋转恢复AVL树的平衡性。

a. 单旋转

LL情形下：

如下图所示：结点k2不满足AVL平衡特性，左子树比右子树的高度高2。通过调整之后，k1成了树根，二叉查找树的性质又使k2成为了k1的右儿子，Y成为了k2的左儿子，二叉查找树的性质没有被破坏，且AVL的特性也恢复了。

对应的，RR情形的单旋转如下：其中k1成为k2的左儿子，Y成为k1的右儿子

b. 双旋转

LR情形：如果插入是在结点的左儿子的右子树中，那么通过单旋转并不能恢复AVL树的平衡特性，如下图：

此时就需要双旋转，如下图所示，调整的过程中首先找出不平衡点k3，顺着k3依次找出3个点：k3,k1,k2，k2是最后一个点，它将成为旋转后的新的根结点，并根据二叉查找树的性质让k1，k3分别成为k2的左右儿子，B和C分别成为k1和k3的右儿子和左儿子：

对应的，对于RL情形，旋转如下：

（3）AVL树插入C++实现

 设计两个类AVLNode和AVLTree，其中AVLTree为AVLNode的友元：

/***********AVLNode.h***********/
#ifndef AVLNODE_H
#define AVLNODE_H

template<class T> class AVLTree;
template<class T>
class AVLNode
{
friend class AVLTree<T>;
public:
    AVLNode()
    {
        data = 0;
        left = NULL;
        right = NULL;
        height = 0;
    }
    AVLNode(T val)
    {
        data = val;
        left = NULL;
        right = NULL;
        height = 0;
    }

public:
    T data;
    AVLNode* left;
    AVLNode* right;
    int height;
};

#endif

/************AVLTree.h**************/
#ifndef AVLTREE_H
#define AVLTREE_H

#include "AVLNode.h"

template<class T>
class AVLTree
{
public:
    AVLTree();
    AVLNode<T>* Insert(const T data, AVLNode<T>* node);
    void LevelOrder(AVLNode<T>* root);
private:
    AVLNode<T>* root;
};

#endif

/************AVLTree.CPP**************/
#include "AVLNode.h"
#include "AVLTree.h"
#include<queue>
#include<iostream>
using namespace std;

template<class T>
AVLTree<T>::AVLTree()
{
    root = NULL;
}

template<class T>
int Height(AVLNode<T>* node)
{
    if(node != NULL)
        return node->height;
    return -1;
}

template<class T>
AVLNode<T>* SingleRotateWithLeft(AVLNode<T>* node)
{
    if(node != NULL)
    {
        AVLNode<T>* k;
        k = node->left;
        node->left = k->right;
        k->right = node;

        node->height = max(Height(node->left),Height(node->right)) + 1;
        k->height = max(Height(k->left),Height(k->right)) + 1;

        return k;
    }
    return NULL;
}

template<class T>
AVLNode<T>* SingleRotateWithRight(AVLNode<T>* node)
{
    if(node != NULL)
    {
        AVLNode<T>* k;
        k = node->right;
        node->right = k->left;
        k->left = node;

        node->height = max(Height(node->left),Height(node->right)) + 1;
        k->height = max(Height(k->left),Height(k->right)) + 1;    

        return k;
    }
    return NULL;
}

template<class T>
AVLNode<T>* DoubleRotateWithLeft(AVLNode<T>* node)
{
    node->left = SingleRotateWithRight(node->left);
    return SingleRotateWithLeft(node);
}

template<class T>
AVLNode<T>* DoubleRotateWithRight(AVLNode<T>* node)
{
    node->right = SingleRotateWithLeft(node->right);
    return SingleRotateWithRight(node);
}

template<class T>
void AVLTree<T>::LevelOrder(AVLNode<T>* root)
{
    if(root != NULL)
    {    
        queue<AVLNode<T>*> q;
        AVLNode<T>* curr = root;
        AVLNode<T>* temp = root;
        while(curr)
        {
            cout<<curr->data<<"("<<curr->height<<")"<<endl;
            if(curr->left)
                q.push(curr->left);
            if(curr->right)
                q.push(curr->right);
            if(!q.empty())
            {
                curr = q.front();
                q.pop();
            }
            else
                curr = NULL;
        }
    }
}

template<class T>
AVLNode<T>* AVLTree<T>::Insert(const T data, AVLNode<T>* root)
{
    if(root == NULL)
        return root = new AVLNode<T>(data);
    else
    {
        AVLNode<T>* node = root;
        if(node->data > data)
        {
            node->left = Insert(data,node->left);
            if(Height(node->left) - Height(node->right) == 2)
            {
                if(data < node->left->data)
                    node = SingleRotateWithLeft(node);
                else
                    node = DoubleRotateWithLeft(node);
            }            
        }
        else if(node->data < data)
        {
            node->right = Insert(data,node->right);
            if(Height(node->right) - Height(node->left) == 2)
            {
                if(data > node->right->data)
                    node = SingleRotateWithRight(node);
                else
                    node = DoubleRotateWithRight(node);
            }
        }
        node->height = max(Height(node->left),Height(node->right))+1;
        return node;
    }
    
}

// AVL.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "AVLNode.h"
#include "AVLTree.h"
#include "AVLTree.cpp"

#include <iostream>

using namespace std;


int _tmain(int argc, _TCHAR* argv[])
{
    AVLTree<int> avl;
    AVLNode<int>* root = avl.Insert(3,NULL);
    root = avl.Insert(2,root);
    root = avl.Insert(1,root);

    avl.LevelOrder(root);

     system("pause");
    return 0;
}