Java数据结构和算法（三）——冒泡、选择、插入排序算法

一、冒泡排序

　　这个名词的由来很好理解，通常河水中的冒泡，水底刚冒出来的时候是比较小的，随着慢慢向水面浮起会逐渐增大，这物理规律我不做过多解释，你们只须要了解便可。

　　冒泡算法的运做规律以下：

　　①、比较相邻的元素。若是第一个比第二个大，就交换他们两个。

　　②、对每一对相邻元素做一样的工做，从开始第一对到结尾的最后一对。这步作完后，最后的元素会是最大的数（也就是第一波冒泡完成）。

　　③、针对全部的元素重复以上的步骤，除了最后一个。

　　④、持续每次对愈来愈少的元素重复上面的步骤，直到没有任何一对数字须要比较。

　　

 

　　

　　代码以下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

package com.ys.sort;   public class BubbleSort {     public static int[] sort(int[] array){         //这里for循环表示总共须要比较多少轮         for(int i = 1 ; i < array.length; i++){             //设定一个标记，若为true，则表示这次循环没有进行交换，也就是待排序列已经有序，排序已经完成。             boolean flag = true;             //这里for循环表示每轮比较参与的元素下标             //对当前无序区间array[0......length-i]进行排序             //j的范围很关键，这个范围是在逐步缩小的,由于每轮比较都会将最大的放在右边             for(int j = 0 ; j < array.length-i ; j++){                 if(array[j]>array[j+1]){                     int temp = array[j];                     array[j] = array[j+1];                     array[j+1] = temp;                     flag = false;                 }             }             if(flag){                 break;             }             //第 i轮排序的结果为             System.out.print("第"+i+"轮排序后的结果为:");             display(array);                       }         return array;               }           //遍历显示数组     public static void display(int[] array){         for(int i = 0 ; i < array.length ; i++){             System.out.print(array[i]+" ");         }         System.out.println();     }           public static void main(String[] args) {         int[] array = {4,2,8,9,5,7,6,1,3};         //未排序数组顺序为         System.out.println("未排序数组顺序为：");         display(array);         System.out.println("-----------------------");         array = sort(array);         System.out.println("-----------------------");         System.out.println("通过冒泡排序后的数组顺序为：");         display(array);     }   }

　　

　　结果以下：

　　

　　原本应该是 8 轮排序的，这里咱们只进行了 7 轮排序，由于第 7 轮排序以后已是有序数组了。

　　冒泡排序解释：

　　冒泡排序是由两个for循环构成，第一个for循环的变量 i 表示总共须要多少轮比较，第二个for循环的变量 j 表示每轮参与比较的元素下标【0,1，......，length-i】，由于每轮比较都会出现一个最大值放在最右边，因此每轮比较后的元素个数都会少一个，这也是为何 j 的范围是逐渐减少的。相信你们理解以后快速写出一个冒泡排序并不难。

　　冒泡排序性能分析：

　　假设参与比较的数组元素个数为 N，则第一轮排序有 N-1 次比较，第二轮有 N-2 次，如此类推，这种序列的求和公式为：

　　（N-1）+（N-2）+...+1 = N*（N-1）/2

　　当 N 的值很大时，算法比较次数约为 N2/2次比较，忽略减1。

　　假设数据是随机的，那么每次比较可能要交换位置，可能不会交换，假设几率为50%，那么交换次数为 N2/4。不过若是是最坏的状况，初始数据是逆序的，那么每次比较都要交换位置。

　　交换和比较次数都和N2 成正比。因为常数不算大 O 表示法中，忽略 2 和 4，那么冒泡排序运行都须要 O(N2) 时间级别。

　　其实不管什么时候，只要看见一个循环嵌套在另外一个循环中，咱们均可以怀疑这个算法的运行时间为 O(N2)级，外层循环执行 N 次，内层循环对每一次外层循环都执行N次（或者几分之N次）。这就意味着大约须要执行N2次某个基本操做。

　　

二、选择排序 

　　选择排序是每一次从待排序的数据元素中选出最小的一个元素，存放在序列的起始位置，直到所有待排序的数据元素排完。

　　分为三步：

　　①、从待排序序列中，找到关键字最小的元素

　　②、若是最小元素不是待排序序列的第一个元素，将其和第一个元素互换

　　③、从余下的 N - 1 个元素中，找出关键字最小的元素，重复(1)、(2)步，直到排序结束

 　　

　　

 

 　　代码以下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

package com.ys.sort;   public class ChoiceSort {     public static int[] sort(int[] array){         //总共要通过N-1轮比较         for(int i = 0 ; i < array.length-1 ; i++){             int min = i;             //每轮须要比较的次数             for(int j = i+1 ; j < array.length ; j++){                 if(array[j]<array[min]){                     min = j;//记录目前能找到的最小值元素的下标                 }             }             //将找到的最小值和i位置所在的值进行交换             if(i != min){                 int temp = array[i];                 array[i] = array[min];                 array[min] = temp;             }             //第 i轮排序的结果为             System.out.print("第"+(i+1)+"轮排序后的结果为:");             display(array);         }         return array;     }       //遍历显示数组     public static void display(int[] array){         for(int i = 0 ; i < array.length ; i++){             System.out.print(array[i]+" ");         }         System.out.println();     }           public static void main(String[] args){         int[] array = {4,2,8,9,5,7,6,1,3};         //未排序数组顺序为         System.out.println("未排序数组顺序为：");         display(array);         System.out.println("-----------------------");         array = sort(array);         System.out.println("-----------------------");         System.out.println("通过选择排序后的数组顺序为：");         display(array);     } }

　　运行结果：

　　

 

　　选择排序性能分析：

　　选择排序和冒泡排序执行了相同次数的比较：N*（N-1）/2，可是至多只进行了N次交换。

　　当 N 值很大时，比较次数是主要的，因此和冒泡排序同样，用大O表示是O(N2) 时间级别。可是因为选择排序交换的次数少，因此选择排序无疑是比冒泡排序快的。当 N 值较小时，若是交换时间比选择时间大的多，那么选择排序是至关快的。

　　

三、插入排序

　　直接插入排序基本思想是每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完全部元素为止。

　　插入排序还分为直接插入排序、二分插入排序、链表插入排序、希尔排序等等，这里咱们只是以直接插入排序讲解，后面讲高级排序的时候会将其余的。

　　　　

 

　　

 

　　代码以下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

package com.ys.sort;   public class InsertSort {     public static int[] sort(int[] array){         int j;         //从下标为1的元素开始选择合适的位置插入，由于下标为0的只有一个元素，默认是有序的         for(int i = 1 ; i < array.length ; i++){             int tmp = array[i];//记录要插入的数据             j = i;             while(j > 0 && tmp < array[j-1]){//从已经排序的序列最右边的开始比较，找到比其小的数                 array[j] = array[j-1];//向后挪动                 j--;             }             array[j] = tmp;//存在比其小的数，插入         }         return array;     }           //遍历显示数组     public static void display(int[] array){         for(int i = 0 ; i < array.length ; i++){             System.out.print(array[i]+" ");         }         System.out.println();     }           public static void main(String[] args){         int[] array = {4,2,8,9,5,7,6,1,3};         //未排序数组顺序为         System.out.println("未排序数组顺序为：");         display(array);         System.out.println("-----------------------");         array = sort(array);         System.out.println("-----------------------");         System.out.println("通过插入排序后的数组顺序为：");         display(array);     }   }

　　运行结果：

　　

　　插入排序性能分析：

　　在第一轮排序中，它最多比较一次，第二轮最多比较两次，一次类推，第N轮，最多比较N-1次。所以有 1+2+3+...+N-1 = N*（N-1）/2。

　　假设在每一轮排序发现插入点时，平均只有全体数据项的一半真的进行了比较，咱们除以2获得：N*（N-1）/4。用大O表示法大体须要须要 O(N2) 时间级别。

　　复制的次数大体等于比较的次数，可是一次复制与一次交换的时间耗时不一样，因此相对于随机数据，插入排序比冒泡快一倍，比选择排序略快。

　　这里须要注意的是，若是要进行逆序排列，那么每次比较和移动都会进行，这时候并不会比冒泡排序快。

 

四、总结

　　上面讲的三种排序，冒泡、选择、插入用大 O 表示法都须要 O(N2) 时间级别。通常不会选择冒泡排序，虽然冒泡排序书写是最简单的，可是平均性能是没有选择排序和插入排序好的。

　　选择排序把交换次数下降到最低，可是比较次数仍是挺大的。当数据量小，而且交换数据相对于比较数据更加耗时的状况下，能够应用选择排序。

　　在大多数状况下，假设数据量比较小或基本有序时，插入排序是三种算法中最好的选择。

　　后面咱们会讲解高级排序，大O表示法的时间级别将比O(N2)小。