C#与数据结构--树论--平衡二叉树(AVL TREE)

来自http://www.cnblogs.com/abatei/archive/2008/11/17/1335031.html

介绍

我们知道在二叉查找树中，如果插入元素的顺序接近有序，那么二叉查找树将退化为链表，从而导致二叉查找树的查找效率大为降低。如何使得二叉查找树无论在什么样情况下都能使它的形态最大限度地接近满二叉树以保证它的查找效率呢？

前苏联科学家G.M. Adelson-Velskii 和 E.M. Landis给出了答案。他们在1962年发表的一篇名为《An algorithm for the organization of information》的文章中提出了一种自平衡二叉查找树（self-balancing binary search tree）。这种二叉查找树在插入和删除操作中，可以通过一系列的旋转操作来保持平衡，从而保证了二叉查找树的查找效率。最终这种二叉查找树以他们的名字命名为“AVL-Tree”，它也被称为平衡二叉树（Balanced Binary Tree）。这里所说的平衡使我们想到了中庸之道，但有句话说得好，“中不偏，庸不易”。学会这种平衡术是一个相当痛苦的过程。

什么是平衡

为了保证平衡，AVL树中的每个结点都有一个平衡因子（balance factor，以下用BF表示），它表示这个结点的左、右子树的高度差，也就是左子树的高度减去右子树的高度的结果值。AVL树上所有结点的BF值只能是-1、0、1。反之，只要二叉树上一个结点的BF的绝对值大于1，则该二叉树就不是平衡二叉树。图1演示了平衡二叉树和非平衡二叉树。

AVL树的构造

如何构造一棵平衡二叉树呢？动态地调整二叉查找树平衡的方法为：每插入一个结点后，首先检查是否破坏了树的平衡性，如果因插入结点而破坏了二叉查找树的平衡，则找出离插入点最近的不平衡结点，然后将该不平衡结点为根的子树进行旋转操作，我们称该不平衡结点为旋转根，以该旋转根为根的子树称为最小不平衡子树。失衡状态可归纳为4种，它们对应着4种旋转类型。下面使用了Flash动画演示了这四种旋转类型，请确保你的电脑安装了Flash8.0以上版本的播放器，并且浏览器允许使用Flash。做这几个动画纯属好玩，希望有一天可以使用Silverlight做这些的动画。不过好象现在还没什么博客支持。

l         LL型旋转

如以上动画所示，插入结点5后，结点50的BF值由1变为2，此时结点50为旋转根。这种插入结点50的左孩子的左子树而导致失衡的情况需要进行LL旋转（LL意为左左）。可以观察到，虽然结点50的BF值由1变为了0，但最小不平衡子树在插入结点5前和旋转后的高度不变。

l         RR型旋转

如以上动画所示，插入结点90后，结点25的BF值由-1变为-2，此时结点25为旋转根。这种插入结点25的右孩子的右子树而导致失衡的情况需要进行RR旋转。最小不平衡子树在插入结点90前和旋转后的高度不变。

l         LR型旋转

 

 

 

插入旋转根的左孩子的右子树而导致失衡的情况需要进行LR旋转。这里演示了LR(L)和LR(R) 两种情况。插入结点前和旋转后的最小不平衡子树高度不变。

l         RL型旋转

 

 

插入旋转根的右孩子的左子树而导致失衡的情况需要进行RL旋转。这里演示了RL(L)和RL(R) 两种情况。插入结点前和旋转后的最小不平衡子树高度不变。

以上动画只演示了几种旋转类型的较复杂的情况，并没有全部演示，比如旋转根的左子树或右子树为空的情况，具体算法请参见稍后的代码。

AVL树上结点的插入

AVL算法的思想理解起来还是不太困难的，但如果真要使用代码实现就没那么简单了，它拥有超高的算法实现复杂度。我查了很多资料，大部分只给出主要算法代码，对于如何回溯修改BF值，如何处理不需要旋转的情况绝口不提，甚至对删除算法直接忽略。上网找资料，中文的，英文的全找了，大部分写代码不加注释，狂汗．．．．，实在看不下去。大部分代码使用递归算法，C#实现更是少得可怜，在国外网站找到一个，但使用了三叉链表实现，多加了一个parent指针，总之无法找到让人满意的代码。最后一咬牙一跺脚，自己实现。最让人头痛的莫过于如何处理插入和删除后的回溯和修改BF值，庆幸的是最终还是按照我最初的想法比较漂亮地实现了AVL树。优点是：无递归；无parent指针；插入和删除操作使用同一旋转方法，使代码更为简化。缺点是：为了兼顾效率，有些地方的处理比较特殊，代码很难完全读懂。

下面对本算法做原理上的介绍：

1、如何回溯修改祖先结点的平衡因子

我们知道，在AVL树上插入一个新结点后，有可能导致其他结点BF值的改变，哪些结点的BF值会被改变？如何计算新的BF值呢？要解决这些问题，我们必须理解以下几个要点：

l         只有根结点到插入结（橙色结点）点路径（称为插入路径）上的结点的BF值会被改变。如图2所示，只有插入路径上结点（灰色结点）的BF值被改变，其他非插入路径上结点的BF值不变。

 

 

 

l         当一个结点插入到某个结点的左子树时，该结点的BF值加1（如图2的结点50、43）；当一个结点插入到某个结点的右子树时，该结点的BF值减1（如图2的结点25、30）。如何在程序中判断一个结点是插入到左子树还是右子树呢？很简单，根据二叉查找树的特性可以得出结论：如果插入结点小于某个结点，则必定是插入到这个结点的左子树中；如果如果插入结点大于某个结点，则必定插入到这个结点的右子树中。

l         修改BF值的操作需从插入点开始向上回溯至根结点依次进行，当路径上某个结点BF值修改后变为0，则修改停止。如图3所示，插入结点30后，首先由于30<43，将结点43的BF值加1，使得结点43的BF值由0变为 1；接下来由于30>25，结点25的BF值由1改为0；此时结点25的BF值为0，停止回溯，不需要再修改插入路径上结点50的平衡因子。道理很简单：当结点的BF值由1或-1变为0，表明高度小的子树添加了新结点，树的高度没有增加，所以不必修改祖先结点的平衡因子；当结点的BF值由0变为1或-1时，表明原本等高左右子树由于一边变高而导致失衡，整棵子树的高度变高，所以必须向上修改祖先结点的BF值。

 

 

2、何时进行旋转操作？如何判断作什么类型的旋转？

在回溯修改祖先结点的平衡因子时，如果碰到某个结点的平衡因子变为2或-2，表明AVL树失衡，这时需要以该结点为旋转根，对最小不平衡子树进行旋转操作。由于是从插入点开始回溯，所以最先碰到的BF值变为2或-2的结点必定为最小不平衡子树的根结点。如图4所示，插入39后，43和50两个结点的BF值都会变为2，而必定先访问到结点43，所以43是最小不平衡子树的根。根据以上Flash动画演示所示，旋转操作完成后，最小不平衡子树插入结点前和旋转完成后的高度不变，所以可以得出结论：旋转操作完成后，无需再回溯修改祖先的BF值。这样，图4中的结点25和50的平衡因子实际上在插入结点操作完成后的BF值不变（对比图2）。

 

 

可以通过旋转根及其孩子的BF值来决定作什么类型的旋转操作：

l         当旋转根的BF值为2时：

如果旋转根的左孩子的BF值为1，则进行LL型旋转；

如果旋转根的左孩子的BF值为-1，则进行LR型旋转。

l         当旋转根的BF值为-2时：

如果旋转根的右孩子的BF值为1，则进行RL型旋转；

如果旋转根的右孩子的BF值为-1，则进行RR型旋转。

可通过观察之前的Flash动画检验以上结论。

3、如何保存插入路径？

可以使用栈来保存插入路径上的各个结点，但由于栈是由数组抽象而来，为了进一步加快AVL树的运行速度，我直接使用数组存放插入路径，这样可以减少方法的调用，尽量避免一些不必要的操作。

如果实现AVL树实现索引器，而在索引器中使用int32，那么AVL树元素的长度不会超过一个32位整数的最大值。一个深度为32的满二叉树可以存放结点数为：2^32-1=4294967295，这个值已经远远超出32位的整数范围，所以我将数组的长度定为32。这样就不必如ArrayList那样进行扩容操作了。另外本程序还使用了一个成员变量p用于指示当前访问结点，由于p指针的存在可以不必在每次进行插入和删除操作后清空数组中的元素，进一步增加了AVL树的运行速度。

使用数组的另一个好处是可以随时访问旋转根的双亲结点，以方便进行旋转操作时修改根结点。

AVL树上结点的删除

AVL树的删除操作与插入操作有许多相似之处，它的大体步骤如下：

⑴用二叉查找树的删除算法找到并删除结点（这里简称为删除点）；

⑵沿删除点向上回溯，必要时，修改祖先结点的BF值；

⑶回溯途中，一旦发现某个祖先的BF值失衡，如插入操作那样旋转不平衡子树使之变为平衡，跟插入操作不同的是，旋转完成后，回溯不能停止，也就是说在AVL树上删除一个结点有可能引起多次旋转。

AVL树上的删除和插入操作虽然大体相似，但还是有一些不同之处，大家需要注意以下几点：

1、  回溯方式的不同

在删除结点的回溯过程中，当某个结点的BF值变为1或-1时，则停止回溯。这一点同插入操作正好相反，因为BF值由0变为1或-1，表明原本平衡的子树由于某个结点的删除导致了不平衡，子树的总体高度不变，所以不再需要向上回溯。

2、旋转方式的不同

如图5所示：删除AVL树中的结点25导致结点50的BF值由原来的-1变为-2，但旋转根50的右孩子的BF值为0，这种情况在前面所讲的旋转操作中并不存在，那么是需要对它进行RR旋转还是RL旋转呢？正确方法是使用RR旋转，所不同之处是旋转后的BF值不同，需要单独处理。需要注意，这种情况在插入操作时不可能发生，LL旋转也存在类型的情况。另外旋转完成后树的整体高度没有改变，所以大部分情况下旋转操作完成后，子树的高度降低，需要继续向上回溯修改祖先的BF值，而只有这种情况由于子树的高度未改变，所以停止回溯。

 

 

 

 

3、删除点的选择特例

在二叉查找树中，我们知道当删除点p既有左子树，又有右子树，此时可以令p的中序遍历直接前驱结点代替p，然后再从二叉查找树中删除它的直接前驱。如图7.13所示，结点5既有左子树，又有右子树，它的直接前驱结点为4。在删除结点5时，首先用结点4代替结点5，然后再删除结点4完成删除操作。这里需要注意的是此时必须将删除前的结点4作为删除点来进行向上回溯操作，而不是结点5。

 

 

 

AVL树的代码实现

这里没有给出AVL树的泛型实现，它只存放整数。因为如果使用泛型实现并按照微软惯例，使用键/值对实现，那么代码真的就很难读懂了。以这个代码为基础，改为泛型实现是很容易的事。另外C#中没AVL树的实现，而实现了红黑树，说明红黑树更有效率，所以也不必将AVL泛型化，代码忽略了部分出错可能。红黑树将在后面讲解。

 

 

Code
public  class BinarySearchTree : IBinaryTree  // 实现画树接口
    {     // 成员变量
         private Node _head;  // 头指针
         private Node[] path =  new Node[ 32];  // 记录访问路径上的结点
         private  int p;  // 表示当前访问到的结点在_path上的索引
        INode IBinaryTree.Head  // 显式接口实现
        {
             get {  return (INode)_head; }
        }
         public  bool Add( int value)  // 添加一个元素
        {    // 如果是空树，则新结点成为二叉排序树的根
             if (_head ==  null)
            {
                _head =  new Node(value);
                _head.BF =  0;
                 return  true;
            }
            p =  0;
             // prev为上一次访问的结点，current为当前访问结点
            Node prev =  null, current = _head;
             while (current !=  null)
            {
                path[p++] = current;  // 将路径上的结点插入数组
                 // 如果插入值已存在，则插入失败
                 if (current.Data == value)
                {
                     return  false;
                }
                prev = current;
                 // 当插入值小于当前结点，则继续访问左子树，否则访问右子树
                current = (value < prev.Data) ? prev.Left : prev.Right;
            }
            current =  new Node(value);  // 创建新结点
            current.BF =  0;
             if (value < prev.Data)  // 如果插入值小于双亲结点的值
            {
                prev.Left = current;  // 成为左孩子
            }
             else  // 如果插入值大于双亲结点的值
            {
                prev.Right = current;  // 成为右孩子
            }
            path[p] = current;  // 将新元素插入数组path的最后
             // 修改插入点至根结点路径上各结点的平衡因子
             int bf =  0;
             while (p >  0)
            {    // bf表示平衡因子的改变量，当新结点插入左子树，则平衡因子+1
                 // 当新结点插入右子树，则平衡因子-1
                bf = (value < path[p -  1].Data) ?  1 : - 1;
                path[--p].BF += bf;  // 改变当父结点的平衡因子
                bf = path[p].BF;  // 获取当前结点的平衡因子
                 // 判断当前结点平衡因子，如果为0表示该子树已平衡，不需再回溯
                 // 而改变祖先结点平衡因子，此时添加成功，直接返回
                 if (bf ==  0)
                {
                     return  true;
                }
                 else  if (bf ==  2 || bf == - 2)  // 需要旋转的情况
                {
                    RotateSubTree(bf);
                     return  true;
                }
            }
             return  true;
        }
         // 删除指定值
         public  bool Remove( int value) 
        {
            p = - 1;
             // parent表示双亲结点，node表示当前结点
            Node node = _head;
             // 寻找指定值所在的结点
             while (node !=  null)
            {
                path[++p] = node;
                 // 如果找到，则调用RemoveNode方法删除结点
                 if (value == node.Data)
                {
                    RemoveNode(node); // 现在p指向被删除结点
                     return  true;  // 返回true表示删除成功
                }
                 if (value < node.Data)
                {    // 如果删除值小于当前结点，则向左子树继续寻找
                    node = node.Left;
                }
                 else
                {    // 如果删除值大于当前结点，则向右子树继续寻找
                    node = node.Right;
                }
            }
             return  false;  // 返回false表示删除失败
        }
         // 删除指定结点
         private  void RemoveNode(Node node)
        {
            Node tmp =  null;
             // 当被删除结点存在左右子树时
             if (node.Left !=  null && node.Right !=  null)
            {
                tmp = node.Left;  // 获取左子树
                path[++p] = tmp;
                 while (tmp.Right !=  null)  // 获取node的中序遍历前驱结点，并存放于tmp中
                {    // 找到左子树中的最右下结点
                    tmp = tmp.Right;
                    path[++p] = tmp;
                }
                 // 用中序遍历前驱结点的值代替被删除结点的值
                node.Data = tmp.Data;
                 if (path[p -  1] == node)
                {
                    path[p -  1].Left = tmp.Left;
                }
                 else
                {
                    path[p -  1].Right = tmp.Left;
                }
            }
             else  // 当只有左子树或右子树或为叶子结点时
            {    // 首先找到惟一的孩子结点
                tmp = node.Left;
                 if (tmp ==  null)  // 如果只有右孩子或没孩子
                {
                    tmp = node.Right;
                }
                 if (p >  0)
                {
                     if (path[p -  1].Left == node)
                    {    // 如果被删结点是左孩子
                        path[p -  1].Left = tmp;
                    }
                     else
                    {    // 如果被删结点是右孩子
                        path[p -  1].Right = tmp;
                    }
                }
                 else   // 当删除的是根结点时
                {
                    _head = tmp;
                }
            }
             // 删除完后进行旋转，现在p指向实际被删除的结点
             int data = node.Data;
             while (p >  0)
            {    // bf表示平衡因子的改变量，当删除的是左子树中的结点时，平衡因子-1
                 // 当删除的是右子树的孩子时，平衡因子+1
                 int bf = (data <= path[p -  1].Data) ? - 1 :  1;
                path[--p].BF += bf;  // 改变当父结点的平衡因子
                bf = path[p].BF;  // 获取当前结点的平衡因子
                 if (bf !=  0)  // 如果bf==0，表明高度降低，继续后上回溯
                {
                     // 如果bf为1或-1则说明高度未变，停止回溯，如果为2或-2，则进行旋转
                     // 当旋转后高度不变，则停止回溯
                     if (bf ==  1 || bf == - 1 || !RotateSubTree(bf))
                    {
                         break;
                    }
                }
            }
        }
         // 旋转以root为根的子树，当高度改变，则返回true；高度未变则返回false
         private  bool RotateSubTree( int bf) 
        {
             bool tallChange =  true;
            Node root = path[p], newRoot =  null;
             if (bf ==  2)  // 当平衡因子为2时需要进行旋转操作
            {
                 int leftBF = root.Left.BF;
                 if (leftBF == - 1)  // LR型旋转
                {
                    newRoot = LR(root);
                }
                 else  if (leftBF ==  1)
                {
                    newRoot = LL(root);  // LL型旋转
                }
                 else  // 当旋转根左孩子的bf为0时，只有删除时才会出现
                {
                    newRoot = LL(root);
                    tallChange =  false;
                }
            }
             if (bf == - 2)  // 当平衡因子为-2时需要进行旋转操作
            {
                 int rightBF = root.Right.BF;  // 获取旋转根右孩子的平衡因子
                 if (rightBF ==  1) 
                {
                    newRoot = RL(root);  // RL型旋转
                }
                 else  if (rightBF == - 1)
                {
                    newRoot = RR(root);  // RR型旋转
                }
                 else  // 当旋转根左孩子的bf为0时，只有删除时才会出现
                {
                    newRoot = RR(root);
                    tallChange =  false;
                }
            }
             // 更改新的子树根
             if (p >  0)
            {
                 if (root.Data < path[p -  1].Data)
                {
                    path[p -  1].Left = newRoot;
                }
                 else
                {
                    path[p -  1].Right = newRoot;
                }
            }
             else
            {
                _head = newRoot;  // 如果旋转根为AVL树的根，则指定新AVL树根结点
            }
             return tallChange;
        }
         // root为旋转根，rootPrev为旋转根双亲结点
         private Node LL(Node root)  // LL型旋转，返回旋转后的新子树根
        {
            Node rootNext = root.Left;
            root.Left = rootNext.Right;
            rootNext.Right = root;
             if (rootNext.BF ==  1)
            {
                root.BF =  0;
                rootNext.BF =  0;
            }
             else  // rootNext.BF==0的情况，删除时用
            {
                root.BF =  1;
                rootNext.BF = - 1;
            }
             return rootNext;  // rootNext为新子树的根
        }
         private Node LR(Node root)  // LR型旋转，返回旋转后的新子树根
        {
            Node rootNext = root.Left;
            Node newRoot = rootNext.Right;
            root.Left = newRoot.Right;
            rootNext.Right = newRoot.Left;
            newRoot.Left = rootNext;
            newRoot.Right = root;
             switch (newRoot.BF)  // 改变平衡因子
            {
                 case  0:
                    root.BF =  0;
                    rootNext.BF =  0;
                     break;
                 case  1:
                    root.BF = - 1;
                    rootNext.BF =  0;
                     break;
                 case - 1:
                    root.BF =  0;
                    rootNext.BF =  1;
                     break;
            }
            newRoot.BF =  0;
             return newRoot;  // newRoot为新子树的根
        }
         private Node RR(Node root)  // RR型旋转，返回旋转后的新子树根
        {
            Node rootNext = root.Right;
            root.Right = rootNext.Left;
            rootNext.Left = root;
             if (rootNext.BF == - 1)
            {
                root.BF =  0;
                rootNext.BF =  0;
            }
             else  // rootNext.BF==0的情况，删除时用
            {
                root.BF = - 1;
                rootNext.BF =  1;
            }
             return rootNext;  // rootNext为新子树的根
        }
         private Node RL(Node root)  // RL型旋转，返回旋转后的新子树根
        {
            Node rootNext = root.Right;
            Node newRoot = rootNext.Left;
            root.Right = newRoot.Left;
            rootNext.Left = newRoot.Right;
            newRoot.Right = rootNext;
            newRoot.Left = root;
             switch (newRoot.BF)  // 改变平衡因子
            {
                 case  0:
                    root.BF =  0;
                    rootNext.BF =  0;
                     break;
                 case  1:
                    root.BF =  0;
                    rootNext.BF = - 1;
                     break;
                 case - 1:
                    root.BF =  1;
                    rootNext.BF =  0;
                     break;
            }
            newRoot.BF =  0;
             return newRoot;  // newRoot为新子树的根
        }
    }