Go语言视频零基础入门到精通

javalearner

形态匀称的二叉树称为平衡二叉树 (Balanced binary tree) ，其严格定义是：
   
一棵空树是平衡二叉树；若 T 是一棵非空二叉树，其左、右子树为 TL 和 TR ，令 hl 和 hr 分别为左、右子树的深度。当且仅当
   
①TL 、 TR 都是平衡二叉树；
   
② ｜ hl － hr ｜≤ 1；
   
时，则 T 是平衡二叉树。
   

   
【例】如图所示。
   

   
   

   
（a）平衡二叉树           （b）非平衡二叉树
   
             图 平衡二叉树与非平衡二叉树
   

   
     相应地定义 hl － hr 为二叉平衡树的平衡因子 (balance factor) 。因此，平衡二叉树上所有结点的平衡因子可能是 -1 ， 0 ， 1 。换言之，若一棵二叉树上任一结点的平衡因子的绝对值都不大于 1 ，则该树是就平衡二叉树。
   

   

    1.动态平衡技术
   
      Adelson-Velskii 和 Landis 提出了一个动态地保持二叉排序树平衡的方法，其基本思想是：
   
       在构造二叉排序树的过程中，每当插入一个结点时，首先检查是否因插入而破坏了树的平衡性，如果是因插入结点而破坏了树的平衡性，则找出其中最小不平衡子树，在保持排序树特性的前提下，调整最小不平衡子树中各结点之间的连接关系，以达到新的平衡。通常将这样得到的平衡二叉排序树简称为 AVL 树。
   

   

    2.最小不平衡子树
   
    以离插入结点最近、且平衡因子绝对值大于 1 的结点作根结点的子树。为了简化讨论，不妨假设二叉排序树的最小不平衡子树的根结点为 A ，则调整该子树的规律可归纳为下列四种情况：
   
（1） LL 型：
   
      新结点 X 插在 A 的左孩子的左子树里。调整方法见图 8.5(a) 。图中以 B 为轴心，将 A 结点从 B 的右上方转到 B 的右下侧，使 A 成为 B 的右孩子。
   

   

   
   

   
图8.5 平衡调整的4种基本类型（结点旁的数字是平衡因子）
   

   

   
（2）RR 型：
   
     新结点 X 插在 A 的右孩子的右子树里。调整方法见图 8.5(b) 。图中以 B 为轴心，将 A 结点从 B 的左上方转到 B 的左下侧，使 A 成为 B 的左孩子。
   

   
（3）LR 型：
   
     新结点 X 插在 A 的左孩子的右子树里。调整方法见图 8.5(c) 。分为两步进行：第一步以 X 为轴心，将 B 从 X 的左上方转到 X 的左下侧，使 B 成为 X 的左孩子， X 成为 A 的左孩子。第二步跟 LL 型一样处理 ( 应以 X 为轴心 ) 。
   

   
（4）RL 型：
   
    新结点 X 插在 A 的右孩子的左子树里。调整方法见图 8.5(d) 。分为两步进行：第一步以 X 为轴心，将 B 从 X 的右上方转到 X 的右下侧，使 B 成为 X 的右孩子， X 成为 A 的右孩子。第二步跟 RR 型一样处理 ( 应以 X 为轴心 ) 。
   

   
【例】
   
     实际的插入情况，可能比图 8.5 要复杂。因为 A 、 B 结点可能还会有子树。现举一例说明:
   
    设一组记录的关键字按以下次序进行插入： 4 、 5 、 7 ， 2 、 1 、 3 、 6 .
   

   
     其生成及调整成二叉平衡树的过程示于图 8.6 。
   

   
     在图 8.6 中，当插入关键字为3的结点后，由于离结点3最近的平衡因子为2的祖先是根结点5。所以，第一次旋转应以结点4为轴心，把结点2从结点4的左上方转到左下侧，从而结点5的左孩子是结点4，结点4的左孩子是结点2，原结点4的左孩子变成了结点2的右孩子。第二步再以结点4为轴心，按LL类型进行转换。这种插入与调整平衡的方法可以编成算法和程序，这里就不再讨论了。
   

   

   
   

   
   图 8.6 二叉平衡树插入结点 ( 结点旁的数字为其平衡因子 )
   

   
AVL树及java实现

1. public class AvlTree< T extends Comparable< ? super T>>
   
2. {
   
3.      private static class AvlNode< T>{//avl树节点
   
4.         
   
5.         AvlNode( T theElement )
   
6.         {
   
7.             this( theElement, null, null );
   
8.         }
   
9.         AvlNode( T theElement, AvlNode< T> lt, AvlNode< T> rt )
   
10.         {
    
11.             element  = theElement;
    
12.             left     = lt;
    
13.             right    = rt;
    
14.             height   = 0;
    
15.         }
    
16.         T           element;      // 节点中的数据
    
17.         AvlNode< T>  left;         // 左儿子
    
18.         AvlNode< T>  right;        // 右儿子
    
19.         int         height;       // 节点的高度
    
20.     }
    
21.      
    
22.     private AvlNode< T> root;//avl树根
    
23.    
    
24.     public AvlTree( )
    
25.     {
    
26.         root = null;
    
27.     }
    
28.    //在avl树中插入数据，重复数据复略
    
29.     public void insert( T x )
    
30.     {
    
31.         root = insert( x, root );
    
32.     }
    
33.    
    
34.     //在avl中删除数据,没有实现
    
35.     public void remove( T x )
    
36.     {
    
37.         System.out.println( "Sorry, remove unimplemented" );
    
38.     }
    
39.   
    
40.      //在avl树中找最小的数据
    
41.     public T findMin( )
    
42.     {
    
43.         if( isEmpty( ) )
    
44.             throw new UnderflowException( );
    
45.         return findMin( root ).element;
    
46.     }
    
47.     //在avl树中找最大的数据
    
48.     public T findMax( )
    
49.     {
    
50.         if( isEmpty( ) )
    
51.             throw new UnderflowException( );
    
52.         return findMax( root ).element;
    
53.     }
    
54.    //搜索
    
55.     public boolean contains( T x )
    
56.     {
    
57.         return contains( x, root );
    
58.     }
    
59.    
    
60.     public void makeEmpty( )
    
61.     {
    
62.         root = null;
    
63.     }
    
64.    
    
65.     public boolean isEmpty( )
    
66.     {
    
67.         return root == null;
    
68.     }
    
69.     //排序输出avl树
    
70.     public void printTree( )
    
71.     {
    
72.         if( isEmpty( ) )
    
73.             System.out.println( "Empty tree" );
    
74.         else
    
75.             printTree( root );
    
76.     }
    
77.    
    
78.    
    
79.     private AvlNode< T> insert( T x, AvlNode< T> t )
    
80.     {
    
81.         if( t == null )
    
82.             return new AvlNode< T>( x, null, null );
    
83.         
    
84.         int compareResult = x.compareTo( t.element );
    
85.         
    
86.         if( compareResult < 0 )
    
87.         {
    
88.             t.left = insert( x, t.left );//将x插入左子树中
    
89.             if( height( t.left ) - height( t.right ) == 2 )//打破平衡
    
90.                 if( x.compareTo( t.left.element ) < 0 )//LL型（左左型）
    
91.                     t = rotateWithLeftChild( t );
    
92.                 else   //LR型（左右型）
    
93.                     t = doubleWithLeftChild( t );
    
94.         }
    
95.         else if( compareResult > 0 )
    
96.         {
    
97.             t.right = insert( x, t.right );//将x插入右子树中
    
98.             if( height( t.right ) - height( t.left ) == 2 )//打破平衡
    
99.                 if( x.compareTo( t.right.element ) > 0 )//RR型（右右型）
    
100.                     t = rotateWithRightChild( t );
     
101.                 else                           //RL型
     
102.                     t = doubleWithRightChild( t );
     
103.         }
     
104.         else
     
105.             ;  // 重复数据，什么也不做
     
106.         t.height = Math.max( height( t.left ), height( t.right ) ) + 1;//更新高度
     
107.         return t;
     
108.     }
     
109.    
     
110.      //找最小
     
111.     private AvlNode< T> findMin( AvlNode< T> t )
     
112.     {
     
113.         if( t == null )
     
114.             return t;
     
115.         while( t.left != null )
     
116.             t = t.left;
     
117.         return t;
     
118.     }
     
119.     //找最大
     
120.     private AvlNode< T> findMax( AvlNode< T> t )
     
121.     {
     
122.         if( t == null )
     
123.             return t;
     
124.         while( t.right != null )
     
125.             t = t.right;
     
126.         return t;
     
127.     }
     
128.     //搜索（查找）
     
129.     private boolean contains( T x, AvlNode
130.    
131.       t )
     
132.     {
     
133.         while( t != null )
     
134.         {
     
135.             int compareResult = x.compareTo( t.element );
     
136.             
     
137.             if( compareResult < 0 )
     
138.                 t = t.left;
     
139.             else if( compareResult > 0 )
     
140.                 t = t.right;
     
141.             else
     
142.                 return true;    // Match
     
143.         }
     
144.         return false;   // No match
     
145.     }
     
146.    //中序遍历avl树
     
147.     private void printTree( AvlNode< T> t )
     
148.     {
     
149.         if( t != null )
     
150.         {
     
151.             printTree( t.left );
     
152.             System.out.println( t.element );
     
153.             printTree( t.right );
     
154.         }
     
155.     }
     
156.   //求高度
     
157.     private int height( AvlNode< T> t )
     
158.     {
     
159.         return t == null ? -1 : t.height;
     
160.     }
     
161.     //带左子树旋转,适用于LL型
     
162.     private AvlNode< T> rotateWithLeftChild( AvlNode< T> k2 )
     
163.     {
     
164.         AvlNode< T> k1 = k2.left;
     
165.         k2.left = k1.right;
     
166.         k1.right = k2;
     
167.         k2.height = Math.max( height( k2.left ), height( k2.right ) ) + 1;
     
168.         k1.height = Math.max( height( k1.left ), k2.height ) + 1;
     
169.         return k1;
     
170.     }
     
171.     //带右子树旋转，适用于RR型
     
172.     private AvlNode< T> rotateWithRightChild( AvlNode< T> k1 )
     
173.     {
     
174.         AvlNode< T> k2 = k1.right;
     
175.         k1.right = k2.left;
     
176.         k2.left = k1;
     
177.         k1.height = Math.max( height( k1.left ), height( k1.right ) ) + 1;
     
178.         k2.height = Math.max( height( k2.right ), k1.height ) + 1;
     
179.         return k2;
     
180.     }
     
181.     //双旋转，适用于LR型
     
182.     private AvlNode< T> doubleWithLeftChild( AvlNode< T> k3 )
     
183.     {
     
184.         k3.left = rotateWithRightChild( k3.left );
     
185.         return rotateWithLeftChild( k3 );
     
186.     }
     
187.     //双旋转,适用于RL型
     
188.     private AvlNode< T> doubleWithRightChild( AvlNode< T> k1 )
     
189.     {
     
190.         k1.right = rotateWithLeftChild( k1.right );
     
191.         return rotateWithRightChild( k1 );
     
192.     }
     
193.   
     
194.         // Test program
     
195.     public static void main( String [ ] args )
     
196.     {
     
197.         AvlTree< Integer> t = new AvlTree< Integer>( );
     
198.         final int NUMS = 4000;
     
199.         final int GAP  =   37;
     
200.         System.out.println( "Checking... (no more output means success)" );
     
201.         for( int i = GAP; i != 0; i = ( i + GAP ) % NUMS )
     
202.             t.insert( i );
     
203.         if( NUMS < 40 )
     
204.             t.printTree( );
     
205.         if( t.findMin( ) != 1 || t.findMax( ) != NUMS - 1 )
     
206.             System.out.println( "FindMin or FindMax error!" );
     
207.         for( int i = 1; i < NUMS; i++ )
     
208.             if( !t.contains( i ) )
     
209.                System.out.println( "Find error1!" );
     
210.     }
     
211. }
     
213.    

复制代码

   
     
     
      
      

        
      

        
      
     
   

  


源码下载：http://file.javaxxz.com/2014/12/4/000755531.zip