冒泡排序

复习一下排序的知识，今天写冒泡排序。

冒泡排序的原理：遍历该数组，比较相邻两个值，如果a[j] > a[j+1],那么交换两个值，即将大的值放到后面，向一个水泡一样冒出去。

public void sort(int[] array) {

  // 外层循环，控制比较到哪截止
  for (int i = 0; i < array.length; i++) {
   // 内层循环，控制那两项进行比较
   for (int j = 0; j < array.length - i - 1; j++) {
    
    // Sort type: asc
//    if (array[j] > array[j + 1]) {
//     this.swap(array, j, j + 1);
//    }
    //Sort type: desc
    if (array[j] < array[j + 1]) {
     this.swap(array, j, j + 1);
    }
   }
  }
 }

冒泡排序的性能：比较次数--O(n*n),交换次数O(n*n).

网上看到有针对冒泡排序的改进：

1. 如果第一遍冒泡的时候没有任何数据的交换，则说明该数组已经是有序的，则退出排序

2. 记录下上一次冒泡排序的交换位置，下一次从 0 到 该点进行内层循环比较 而不是 0 到 a.length-i-1.

 自己做了一下测试2：

public void sortWithControl(int[] array) {

  int last_swap_index = array.length - 1;

  // 外层循环，控制比较到哪截止
  for (int i = 0; i < array.length; i++) {

   int temp = last_swap_index ;
   
   // 内层循环，控制那两项进行比较
   for (int j = 0; j < temp; j++) {
    // Sort type: asc
    if (array[j] > array[j + 1]) {
     swap(array, j, j + 1);
     last_swap_index = j;
    }
   }
  }
 }

每次试验都是做了计算了10次排序所需时间总和

数组个数-----------------普通sort-------------------改进后sort

10000                       4313                            4265

                                 4046                            4266

                                 4079                            4297

                                 4232                            4236

                                 4203                            4296

5000                         1282                            1311

                                 1172                            1204

                                 1188                            1220

                                 1061                            1376

                                 1187                            1094

1000                         140                              157

                                 94                                265          

...

我没看出有什么改善来，或者我写的改进程序有bug？