常见排序算法 - Java实现

1.冒泡排序

　　每次比较相邻的两个元素大小，调整顺序。从头到尾执行一轮（ｉ），最大数值的元素就排到最后。每次从头到尾执行一轮，都会排好一个元素（length - i - 1）。这就是说一个包含 n 个元素的数组，最大需要 n - 1 次就可以完成数组排序。代码如下：

 public static void bubbleSort(int[] array) {
     int length = array.length;
     for (int i = 0; i < length - 1; i++) {
         for (int j = 0; j < length - i - 1; j++) {
             if (array[j] > array[j + 1]) {
                 array[j] ^= array[j + 1];
                 array[j + 1] ^= array[j];
                 array[j] ^= array[j + 1];
             }
         }

         System.out.print("排序次数 - " + (i+1) + "次：");
         printArray(array);
     }
 }

　　测试的方法要是选择极端情况（已经排好序，只不过是个相反的）。那么就结结实实执行 n-1 轮比较。但是往往不是每次都如此极端，排序时就会有几轮是空转的。这时可以使用一个开关对上边的冒泡排序进行优化。

 // BubbleSort 冒泡排序， 优化一下
 public static void bubbleSortOpt(int[] array) {
     int length = array.length;
     for (int i = 0; i < length - 1; i++) {
         int exitFlag = 0; // 增加一个退出开关
         for (int j = 0; j < length - i - 1; j++) {
             if (array[j] > array[j + 1]) {
                 array[j] ^= array[j + 1];
                 array[j + 1] ^= array[j];
                 array[j] ^= array[j + 1];

                 exitFlag++; // 排序完成时，不会触动这个开关
             }
         }
         if (0 == exitFlag) { // 开关没有动的时候，排序结束
             break;
         }

         System.out.print("排序次数 - " + (i + 1) + "次：");
         printArray(array);
     }
 }

2.选择排序

　　遍历数组，找出最小的元素，与首个元素交换位置。再次遍历未排序的数组元素，与首个未排序的元素交换位置。需要找出 n-1 次最小值，就可以完成排序。

算法实现时，借助两个算法，一个找出数组的最大值，一个获取数组元素的下标。

 // k值为true，返回数组 最大值； 反之为false，返回数组 最小值
 public static int getMaxMinValue(int[] array, int start, boolean k) {
     int keyValue = array[start];
     for (int i = start + 1; i < array.length; i++) {
         if (keyValue > array[i] ^ k) {
             keyValue = array[i];
         }
     }

     return keyValue;
 }

 // 获取指定元素的下标
 public static int getIndexOfArray(int[] array, int num) {
     for (int i = 0; i < array.length; i++) {
         if (array[i] == num) {
             return i;
         }
     }
     return -1;
 }

选择排序方法：

 // SelectSort 选择排序
 public static void SelectSort(int[] array) {
     int length = array.length;
     int minValue;
     int minIndex;

     for (int i = 0; i < length - 1; i++) {
         minValue = getMaxMinValue(array, i, false);
         minIndex = getIndexOfArray(array, minValue);
         if (minIndex != i) {
             // 交换位置
             array[i] ^= array[minIndex];
             array[minIndex] ^= array[i];
             array[i] ^= array[minIndex];
         }

         System.out.print("排序次数 - " + (i + 1) + "次：");
         printArray(array);
     }
 }

　　要是需要排序的数组，刚好是逆序的。这个时候，经过 (int) (n/2) 轮比较，就已经完成整个数组的排序了，后续全都是空转。同样可以增加开关优化代码执行。

 // SelectSort 选择排序，优化一下啊
 public static void SelectSortOpt(int[] array) {
     int length = array.length;
     int minValue;
     int minIndex;

     for (int i = 0; i < length - 1; i++) {
         minValue = getMaxMinValue(array, i, false);
         minIndex = getIndexOfArray(array, minValue);
         int exitFlag = 0; // 增加一个退出开关
         if (minIndex != i) {
             // 交换位置
             array[i] ^= array[minIndex];
             array[minIndex] ^= array[i];
             array[i] ^= array[minIndex];

             exitFlag++; // 排序完成时，不会触动这个开关
         }
         if (0 == exitFlag) { // 开关没有动的时候，排序结束
             break;
         }

         System.out.print("排序次数 - " + (i + 1) + "次：");
         printArray(array);
     }
 }

3.插入排序

3.1.直接插入排序

　　把需要排序的数组元素，依次插入已排序的数组中，返回这个有序数组就是排序好的效果。

 // directInsertionSort 直接插入排序
 public static void directInsertionSort(int[] array) {
     int length = array.length;
     int count=0;
     for (int i = 1; i < length; i++) { // 未排序数组
         for (int j = 0; j < i; j++) { // 已排序数组
             if (array[i] < array[j]) {
                 // 这里可不是互换，而是依次移动数组元素。内层for循环轮询了一遍有序数组。
                 // 极端情况下，每个已排序元素都要移动一次
                 array[i] ^= array[j];
                 array[j] ^= array[i];
                 array[i] ^= array[j];
                 count++;
             }
         }

         System.out.print("排序次数 - " + count + "次：");
         printArray(array);
     }
 }

代码看着不多，觉得运算量太大了。

3.2.希尔排序

　　在直接插入排序的基础上完成希尔排序。

　　选取关键字，把数组分组，组内使用直接插入排序。直到关键字为１。

4.归并排序

5.快速排序

　　使用递归思想，把数组分成两份。每份单独排序