关于冒泡排序的工作原理有几种，有的资料说是第k+x个位置与第k个位置比较（x>0的自然数），符合交换条件就交换。有的资料说是第k+1个位置与第k个位置比较。

• 我刚查资料总结了一下。我觉得既然是冒泡，那就应该所有元素每一趟排序就应该最多往上冒一层。不可能是从水底直接冒到水面。
• 所以正确的排序思想应该是：相邻的两个元素相比较，符合冒泡才冒泡（交换）。

根据上述的正宗原理：第一次得出的代码应该是：

package com.you.test;

public class test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        int[] a = {8,1,6,2,5,7,3,4,9};
        int tmp = 0;//缓存区
        
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a.length-1;j++){
                if (a[j]>a[j+1]) {//符合冒泡，进行一次冒泡
                    tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = tmp;
                }    
            }
            //这一趟排序结束
            printa(a);
        }
        

    }
    
    public static void printa(int[] a) {
        for(int i=0;i<a.length;i++){
            System.out.print(" "+a[i]);
        }
        System.out.println("");
    }

}

运行结果：而且时间复杂度：n*n

1. 解决内外循环次数问题。改进如下：

2. package com.you.test;
   
   public class test {
   
       public static void main(String[] args) {
           // TODO Auto-generated method stub
           
           int[] a = {8,1,6,2,5,7,3,4,9};
           int tmp = 0;//缓存区
           
           //大（小）的数一直往下沉，直到底，小（大）的数一层层往上冒。所以尾部部分是排好序的。
           for(int i=0;i<a.length-1;i++){
               for(int j=0;j<a.length-i-1;j++){
                   if (a[j]>a[j+1]) {//符合冒泡，进行一次冒泡
                       tmp = a[j];
                       a[j] = a[j+1];
                       a[j+1] = tmp;
                   }    
               }
               //这一趟排序结束
               printa(a);
           }
           
   
       }
       
       public static void printa(int[] a) {
           for(int i=0;i<a.length;i++){
               System.out.print(" "+a[i]);
           }
           System.out.println("");
       }
   
   }

   
   运行结果：内部循环次数变小，外部不变。

3. 无效循环还是存在，接下来对无效循环改进：代码：

4. package com.you.test;
   
   public class test {
   
       public static void main(String[] args) {
           // TODO Auto-generated method stub
           
           int[] a = {8,1,6,2,5,7,3,4,9};
           int tmp = 0;//缓存区
           boolean is_changed = true;//冒泡标识，
           
           //大（小）的数一直往下沉，直到底，小（大）的数一层层往上冒。所以尾部部分是排好序的。
           while(is_changed){
               is_changed = false;
               for(int j=0;j<a.length-1;j++){
                   if (a[j]>a[j+1]) {//符合冒泡，进行一次冒泡
                       tmp = a[j];
                       a[j] = a[j+1];
                       a[j+1] = tmp;
                       is_changed = true;//有元素冒泡，
                   }    
               }
               //这一趟排序结束
               printa(a);
           }
       }
       
       //打印
       public static void printa(int[] a) {
           for(int i=0;i<a.length;i++){
               System.out.print(" "+a[i]);
           }
           System.out.println("");
       }
   
   }

   运行结果：

5. 

   到这里就可以就可以完美完成冒泡的改进啦。。。。

正宗冒泡排序算法总结