平衡二叉树平衡二叉树（AVL）--查找、删除、插入（Java实现）

间时紧张，先记一笔，后续优化与完善。

媒介

后面一篇文章，笔者就二叉找查树行进了一些解释与实现，这篇文章笔者将会就平衡二叉树

做一些总结与实现。读者若不懂得二叉找查树的话，可以考参这篇文章：

http://blog.csdn.net/kiritor/article/details/8889176
在习学平衡二叉树之前，我们先顾回下二叉找查树的特色和质性。

基于二叉找查树以下的操纵是低能性的：

1、如果我们向一棵空的二叉找查树中入插一个先预排好序的序列的（升序），根据入插

操纵我们会发现构成的二叉树结点次层太深，且没有左儿子结点。情况如下：



这样就造成了二叉树的深度过深，显著不合理。

2、在二叉找查树的情况下，对于意任个单一的操纵我们不再保障O（logN）的间时界

但是我们可以明证的是在连续M次操纵间时花费可能到达O（MlogN）,耗消太高了。

基于上述的原因，我们就须要斟酌平衡二叉树了。

平衡二叉树

首先须要白明的是平衡二叉树是对二叉找查的一种进改，对于二叉找查树的一个显著的

缺陷就是，树的结构仍旧拥有极大的变化性，最坏的情况下就是一棵单支二叉树，丧失了二叉

找查树一些原有的点优。

平衡二叉树定义（AVL）：它或者是一棵空树，或者是拥有一下质性的二叉找查树--

它的结点左子树和右子树的深度之差不超越1,而且该结点的左子树和右子树都是一棵

平衡二叉树。

平衡因子：结点左子树的深度-结点右子树的深度。（0、1、-1）。



转换为平衡二叉树后之的二叉树为：

平衡持保

很显然，平衡二叉树旨在“平衡”二字，其平衡是如何持保的呢？换句话说，二叉找查树是

如何转换为平衡二叉树的呢？就像下面两张图片，到底如何转换的呢？基本的想思就是:

当二叉找查树中入插一个结点时，首先查检是不是因为入插而破坏了平衡。若破坏了则

找出其中的最小不平衡二叉树，在持保二叉找查树特性的情况下，整调最小不平衡子树中结

点之间的关系，以到达平衡。

最小不平衡二叉树指距离入插结点近最且以平衡因子的绝对值大于1的结点作为根的子树。

那么最小不平衡二叉树结点的关系是底到如何行进整调的呢？分为四种情况论讨。

四种不平衡类型

有四种情况可以致导二叉树不平衡：（以根结点为例）

1、LL型（右旋操纵）：入插一个新的结点到根结点的左子树的左子树，致导根结点的平衡

因子1为变2。



其右旋操纵我们以一个具体的例子掌握：



以第一列为例，在结点2的左子树入插结点D，入插后2结点的平衡因子为变1,致导

结点5(根结点）的平衡因子为变2，则结点5为根结点的子树是最小不平衡子树。整调时

将结点5的左孩子3向右上旋转代替结点5为根结点，将根结点右下旋转为3的右子树的根

结点，而结点3的原右子树为变结点5的左子树。

在结点2的右孩子处入插的情况原理一样的。

2、RR型（左旋操纵）：入插一个新的结点到根结点的右子树的右子树，致导根结点的平衡

因子1为变2。



其具体的操纵我们同样以一个例子为例：



其操纵步骤与右旋操纵没有什么太大的区别，这里笔者就不详述过程了。

3、LR型（左旋+右旋）：在根结点的左孩子的右子树上入插结点，入插情况笔者就

不给实例图了。直接演示其操纵过程。



可见的是LR型须要两次的旋转才能到达要求，不过在行进右旋操纵的时候须要注意C

的位置。

4、RL型（右旋+左旋）在根结点的右子树的左子树上入插结点。同样以一个实例图

来演示操纵。

完整源码实现：

根据上述的旋转操纵，我们简单的实现二叉平衡树：

每日一道理

生活中受伤难免，失败跌倒并不可怕，可怕的是因此而一蹶不振，失去了对人生的追求与远大的理想。没有一个人的前进道路是平平稳稳的，就算是河中穿梭航行的船只也难免颠簸，生活中所遇上的坎坷磨难不是偶尔给予的为难，而是必然所经受的磨练。

package com.kiritor;
/**
*二叉平衡树简单实现
*@author kiritor
*/
public class AvlTree< T extends Comparable< ? super T>>
{
private static class AvlNode< T>{//avl树节点

AvlNode( T theElement )
{
this( theElement, null, null );
}
AvlNode( T theElement, AvlNode< T> lt, AvlNode< T> rt )
{
element  = theElement;
left     = lt;
right    = rt;
height   = 0;
}
T           element;      // 节点中的数据
AvlNode< T>  left;         // 左儿子
AvlNode< T>  right;        // 右儿子
int         height;       // 节点的高度
}

private AvlNode< T> root;//avl树根

public AvlTree( )
{
root = null;
}
//在avl树中入插数据，重复数据复略
public void insert( T x )
{
root = insert( x, root );
}

//在avl中删除数据,这里并未实现
public void remove( T x )
{
System.out.println( "Sorry, remove unimplemented" );
}

//在avl树中找最小的数据
public T findMin( )
{
if( isEmpty( ) )
System.out.println("树空");;
return findMin( root ).element;
}
//在avl树中找最大的数据
public T findMax( )
{
if( isEmpty( ) )
System.out.println("树空");
return findMax( root ).element;
}
//搜索
public boolean contains( T x )
{
return contains( x, root );
}

public void makeEmpty( )
{
root = null;
}

public boolean isEmpty( )
{
return root == null;
}
//排序输出avl树
public void printTree( )
{
if( isEmpty( ) )
System.out.println( "Empty tree" );
else
printTree( root );
}

private AvlNode< T> insert( T x, AvlNode< T> t )
{
if( t == null )
return new AvlNode< T>( x, null, null );

int compareResult = x.compareTo( t.element );

if( compareResult < 0 )
{
t.left = insert( x, t.left );//将x入插左子树中
if( height( t.left ) - height( t.right ) == 2 )//打破平衡
if( x.compareTo( t.left.element ) < 0 )//LL型（左左型）
t = rotateWithLeftChild( t );
else   //LR型（左右型）
t = doubleWithLeftChild( t );
}
else if( compareResult > 0 )
{
t.right = insert( x, t.right );//将x入插右子树中
if( height( t.right ) - height( t.left ) == 2 )//打破平衡
if( x.compareTo( t.right.element ) > 0 )//RR型（右右型）
t = rotateWithRightChild( t );
else                           //RL型
t = doubleWithRightChild( t );
}
else
;  // 重复数据，什么也不做
t.height = Math.max( height( t.left ), height( t.right ) ) + 1;//更新高度
return t;
}

//找最小
private AvlNode< T> findMin( AvlNode< T> t )
{
if( t == null )
return t;
while( t.left != null )
t = t.left;
return t;
}
//找最大
private AvlNode< T> findMax( AvlNode< T> t )
{
if( t == null )
return t;
while( t.right != null )
t = t.right;
return t;
}
//搜索（找查）
private boolean contains( T x, AvlNode t )
{
while( t != null )
{
int compareResult = x.compareTo( (T) t.element );

if( compareResult < 0 )
t = t.left;
else if( compareResult > 0 )
t = t.right;
else
return true;    // Match
}
return false;   // No match
}
//中序遍历avl树
private void printTree( AvlNode< T> t )
{
if( t != null )
{
printTree( t.left );
System.out.println( t.element );
printTree( t.right );
}
}
//求高度
private int height( AvlNode< T> t )
{
return t == null ? -1 : t.height;
}
//带左子树旋转,适用于LL型
private AvlNode< T> rotateWithLeftChild( AvlNode< T> k2 )
{
AvlNode< T> k1 = k2.left;
k2.left = k1.right;
k1.right = k2;
k2.height = Math.max( height( k2.left ), height( k2.right ) ) + 1;
k1.height = Math.max( height( k1.left ), k2.height ) + 1;
return k1;
}
//带右子树旋转，适用于RR型
private AvlNode< T> rotateWithRightChild( AvlNode< T> k1 )
{
AvlNode< T> k2 = k1.right;
k1.right = k2.left;
k2.left = k1;
k1.height = Math.max( height( k1.left ), height( k1.right ) ) + 1;
k2.height = Math.max( height( k2.right ), k1.height ) + 1;
return k2;
}
//双旋转，适用于LR型
private AvlNode< T> doubleWithLeftChild( AvlNode< T> k3 )
{
k3.left = rotateWithRightChild( k3.left );
return rotateWithLeftChild( k3 );
}
//双旋转,适用于RL型
private AvlNode< T> doubleWithRightChild( AvlNode< T> k1 )
{
k1.right = rotateWithLeftChild( k1.right );
return rotateWithRightChild( k1 );
}
// Test program
public static void main( String [ ] args )
{
AvlTree< Integer> t = new AvlTree< Integer>( );
final int NUMS = 200;
final int GAP  =   17;
System.out.println( "Checking... (no more output means success)" );
for( int i = GAP; i != 0; i = ( i + GAP ) % NUMS )
t.insert( i );
t.printTree( );
System.out.println(t.height(t.root));

}
}

上述main函数中我们简单的入插了1-199个数至二叉树中，如果是二叉找查树的话，可以

知道的是二叉树的层树应该为199，但是实际情况如何呢？



文章结束给大家分享下程序员的一些笑话语录：

小沈阳版程序员~~~ \n程序员其实可痛苦的了......需求一做一改，一个月就过去了；嚎~ \n需求再一改一调，一季度就过去了；嚎~ \n程序员最痛苦的事儿是啥，知道不？就是，程序没做完，需求又改了； \n程序员最最痛苦的事儿是啥，知道不？ 就是，系统好不容易做完了，方案全改了； \n程序员最最最痛苦的事儿是啥，知道不？ 就是，系统做完了，狗日的客户跑了； \n程序员最最最最最痛苦的事儿是啥，知道不？ 就是，狗日的客户又回来了,程序给删没了！