冒泡和下沉算法同时应用可以解决冒泡排序的均衡性缺失的问题

均衡性：只要数据结构相似的，处理时的代价应该也相似。冒泡排序缺乏均衡性，冒泡排序和下沉排序能够很好的解决冒泡算法
的“均衡性缺失”。比如数据结构相似的俩数组：（1）1 2 3 4 5 6 0和（2）6 0 1 2 3 4 5 ，用冒泡排序，前者要进行六次循环，
而后者只需进行一次循环即可。对于下沉算法的，前者仅需要进行一次循环，而后者需要进行六次循环。于是把下沉可冒泡排序结
合起来的话，无论哪个数组，都仅需一次循环即可完成排序，解决了冒泡排序的“均衡性缺失”。而且可以将结果出来的时间压缩一半。

示例程序如下：
public class ArraySorter425
{
 static void bubblesort(int array[])
 { //冒泡排序算法
  for(int i=0;i<(array.length-1)/2;i++)
  {
   for(int j=0;j<array.length-i-1;j++)
   {
    if(array[j]>array[j+1])
    {
     int temp=array[j];
     array[j]=array[j+1];
     array[j+1]=temp;
    }
   }
  //下沉排序算法
   for(int k=array.length-2;k>=i;k--)
   {
    if(array[k+1]<array[k])
    {
     int temp=array[k];
     array[k]=array[k+1];
     array[k+1]=temp;
    }
   }

   print(i+1,array);
  }  
 }

 public static void print(int time,int array[])
 {
  System.out.print("第"+time+"次比较结果是:");
  for(int i=0;i<array.length;i++)
  System.out.print(array[i]+" ");
  System.out.println();
 }

 public static void main(String[] args)
 {
  int array[]={15,5,1,4,8,7,9,10,2,11,23,14};
  bubblesort(array);

 }
}

只用冒泡排序输出（外循环次数应再设为“array.length-1”）：

E:/xuexi/java/swq>javac ArraySorter425.java

E:/xuexi/java/swq>java ArraySorter425
第1次比较结果是:5 1 4 8 7 9 10 2 11 15 14 23
第2次比较结果是:1 4 5 7 8 9 2 10 11 14 15 23
第3次比较结果是:1 4 5 7 8 2 9 10 11 14 15 23
第4次比较结果是:1 4 5 7 2 8 9 10 11 14 15 23
第5次比较结果是:1 4 5 2 7 8 9 10 11 14 15 23
第6次比较结果是:1 4 2 5 7 8 9 10 11 14 15 23
第7次比较结果是:1 2 4 5 7 8 9 10 11 14 15 23
第8次比较结果是:1 2 4 5 7 8 9 10 11 14 15 23
第9次比较结果是:1 2 4 5 7 8 9 10 11 14 15 23
第10次比较结果是:1 2 4 5 7 8 9 10 11 14 15 23
第11次比较结果是:1 2 4 5 7 8 9 10 11 14 15 23

E:/xuexi/java/swq>

同时用冒泡和下沉算法的输出结果如下：

E:/xuexi/java/swq>java ArraySorter425
第1次比较结果是:1 5 2 4 8 7 9 10 11 14 15 23
第2次比较结果是:1 2 4 5 7 8 9 10 11 14 15 23
第3次比较结果是:1 2 4 5 7 8 9 10 11 14 15 23
第4次比较结果是:1 2 4 5 7 8 9 10 11 14 15 23
第5次比较结果是:1 2 4 5 7 8 9 10 11 14 15 23