七种经典排序算法及Java实现

排序算法稳定性表示两个值相同的元素在排序前后是否有位置变化。如果前后位置变化，则排序算法是不稳定的，否则是稳定的。稳定性的定义符合常理，两个值相同的元素无需再次交换位置，交换位置是做了一次无用功。

下面为七种经典排序算法指标对比情况：

一、插入排序 InsertionSort

介绍：

插入排序的工作原理是，对于每个未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

步骤：

  1. 从第一个元素开始，该元素可以认为已经被排序
  2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
  3. 如果被扫描的元素（已排序）大于新元素，将该元素后移一位
  4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
  5. 将新元素插入到该位置后
  6. 重复步骤2~5

排序演示：

  1. /** 
  2.      * 插入排序算法 
  3.      * @param nums 被排序的数组 
  4.      * @param n 数组长度 
  5.      * 最坏情况：输入数组已反向排序  O（n2）； 最好情况：输入数组已排序  O（n）；平均情况：O（n2） 
  6.      * 由于插入排序其内层循环非常紧凑，对于小规模输入，插入排序是一种非常快的排序算法 
  7.      */  
  8.     public void InsertSort(int[] nums,int len){  
  9.         int j;  
  10.         for(int i=1;i<len;i++){  
  11.             int temp = nums[i];  
  12.             for(j=i;j>0;j--){  
  13.                 if(temp < nums[j-1]){  
  14.                     nums[j] = nums[j-1]; //将所有在nums[i]之前的大于nums[i]的值都往后移一位  
  15.                 }  
  16.                 else break;   
  17.             }  
  18.             //移完所有大于nums[i]的值后，j刚好指向最靠前一个大于nums[i]的位置  
  19.             nums[j] = temp;  
  20.         }  
  21.         System.out.println("插入排序：");  
  22.         for (int i : nums) {  
  23.             System.out.print(i+" ");  
  24.         }  
  25.     }  

二、希尔排序 ShellSort

介绍：

希尔排序，也称递减增量排序算法，实质是分组插入排序。由 Donald Shell 于1959年提出。希尔排序是非稳定排序算法。

希尔排序的基本思想是：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。

例如，假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我们以步长为5开始进行排序，我们可以通过将这列表放在有5列的表中来更好地描述算法，这样他们就应该看起来是这样：

13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10

然后我们对每列进行排序：

10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45

将上述四行数字，依序接在一起时我们得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]。这时10已经移至正确位置了，然后再以3为步长进行排序：

10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45

排序之后变为：

10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94

最后以1步长进行排序（此时就是简单的插入排序了）。

  1. /** 
  2.      * 希尔排序算法 
  3.      * @param nums 被排序的数组 
  4.      * @param n 数组长度 
  5.      * 最坏情况：O（n2） 使用Hibbard增量的最坏情况：O（n^3/2） 
  6.      */  
  7.     public void ShellSort(int[] nums,int len){  
  8.         int increment;  
  9.         int temp,i,j;  
  10.         for(increment = len/2;increment > 0;increment /= 2){ //增量为len/2 len/4 len/8.....1  
  11.             for(i=increment;i<len;i++){ //对每个子序列进行插入排序  
  12.                 temp = nums[i];  
  13.                 for(j=i;j>=increment;j -= increment){  
  14.                     if(temp < nums[j-increment]){  
  15.                         nums[j] = nums[j-increment];  
  16.                     }  
  17.                     else  
  18.                         break;  
  19.                 }  
  20.                 nums[j] = temp;  
  21.             }  
  22.         }  
  23.         System.out.println("希尔排序：");  
  24.         for (int k : nums) {  
  25.             System.out.print(k+" ");  
  26.         }  
  27.     }  

三、选择排序 SelectionSort

介绍：

选择排序无疑是最简单直观的排序。它的工作原理如下。

步骤：

  1. 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
  2. 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
  3. 以此类推，直到所有元素均排序完毕。
  1. /** 
  2.      * 选择排序算法 
  3.      * 基本思想是：每一趟从待排序的记录中选出关键字最小的记录，顺序放在已排好序的子序列前面，直到全部记录排序完毕。 
  4.      * @param nums 被排序的数组 
  5.      * @param n 数组长度 
  6.      * 最坏情况：O（n2） ，最好情况：O（n2） 
  7.      */  
  8.     public void SelectSort(int[] nums,int len){  
  9.         for(int i=0;i<len;i++){  
  10.             int min = nums[i]; //先把每一趟最小值暂定为nums[i]  
  11.             int index = i; //记录最小值所在的索引值  
  12.             for(int j=i+1;j<len;j++){ //开始一趟比较：从i+1位置到数组末尾比较，找出最小值并记录位置  
  13.                 if(nums[j] < min){  
  14.                     min = nums[j];  
  15.                     index = j;  
  16.                 }  
  17.             }  
  18.             //将nums[i]和最小值交换  
  19.             nums[index] = nums[i];   
  20.             nums[i] = min;  
  21.         }  
  22.         System.out.println("选择排序：");  
  23.         for (int i : nums) {  
  24.             System.out.print(i+" ");  
  25.         }  

四、堆排序 HeapSort

介绍：

堆排序在 top K 问题中使用比较频繁。堆排序是采用二叉堆的数据结构来实现的，虽然实质上还是一维数组。二叉堆是一个近似完全二叉树 。

二叉堆具有以下性质：

  1. 父节点的键值总是大于或等于（小于或等于）任何一个子节点的键值。
  2. 每个节点的左右子树都是一个二叉堆（都是最大堆或最小堆）。

步骤：

  1. 构造最大堆（Build_Max_Heap）：若数组下标范围为0~n，考虑到单独一个元素是大根堆，则从下标n/2开始的元素均为大根堆。于是只要从n/2-1开始，向前依次构造大根堆，这样就能保证，构造到某个节点时，它的左右子树都已经是大根堆。

  2. 堆排序（HeapSort）：由于堆是用数组模拟的。得到一个大根堆后，数组内部并不是有序的。因此需要将堆化数组有序化。思想是移除根节点，并做最大堆调整的递归运算。第一次将heap[0]与heap[n-1]交换，再对heap[0...n-2]做最大堆调整。第二次将heap[0]与heap[n-2]交换，再对heap[0...n-3]做最大堆调整。重复该操作直至heap[0]和heap[1]交换。由于每次都是将最大的数并入到后面的有序区间，故操作完后整个数组就是有序的了。

  3. 最大堆调整（Max_Heapify）：该方法是提供给上述两个过程调用的。目的是将堆的末端子节点作调整，使得子节点永远小于父节点 。

排序演示：

  1. /** 
  2.      * 堆排序算法(max堆) 
  3.      * @param nums 被排序的数组 
  4.      * @param n 数组长度 
  5.      * 时间复杂度 O（nlogn） 
  6.      * 要先构建最大堆，然后循环删除堆的根节点上的最大值，并将它移到堆末尾，并将堆长度减一，再开始下一次的删除根节点 
  7.      */  
  8.     public void HeapSort(int[] nums,int len){  
  9.         //构建最大堆  
  10.         for(int i=len/2;i>=0;i--){  
  11.             percDown(nums,i,len);  
  12.         }  
  13.         //循环，每次把根节点和最后一个节点调换位置  
  14.         for(int i=len-1;i>=1;i--){  
  15.             //Swap(nums[0],nums[i])交换nums[0]和nums[i]  
  16.             int temp = nums[0];  
  17.             nums[0] = nums[i];  
  18.             nums[i] = temp;  
  19.             percDown(nums,0,i);  
  20.         }  
  21.           
  22.         System.out.println("堆排序：");  
  23.         for (int k : nums) {  
  24.             System.out.print(k+" ");  
  25.         }  
  26.     }  
  27.         /** 
  28.          * 堆调整，使其生成最大堆 
  29.          * @param nums 
  30.          * @param i 
  31.          * @param size 
  32.          */  
  33.         public void percDown(int[] nums,int i,int size){  
  34.             int left = 2*i+1;  
  35.             int right = 2*i+2;  
  36.             int max = i;  
  37.             if(left < size && nums[left] > nums[max]){  
  38.                 max = left;  
  39.             }  
  40.             if(right < size && nums[right] > nums[max]){  
  41.                 max = right;  
  42.             }  
  43.             if(max != i){  
  44.                 int temp = nums[i];  
  45.                 nums[i] = nums[max];  
  46.                 nums[max] = temp;  
  47.                 percDown(nums,max,size);  
  48.             }  
  49.               
  50.         }  

五、冒泡排序 BubbleSort

介绍：

冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

步骤：

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  2. 对第0个到第n-1个数据做同样的工作。这时，最大的数就“浮”到了数组最后的位置上。
  3. 针对所有的元素重复以上的步骤，除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
  1. /** 
  2.      * 冒泡排序算法 
  3.      * 原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束 
  4.      * @param nums 被排序的数组 
  5.      * @param n 数组长度 
  6.      * 最坏情况：O(n2)  如果未优化的冒泡排序，最好情况也是O（n2），优化后最好情况是O（n） 
  7.      */  
  8.     public void BubbleSort(int[] nums,int len){  
  9.         for(int i=0;i<len-1;i++){ //一趟比较  
  10.             for(int j=0;j<len-1-i;j++){ //一次比较,每次把最大值放在最后面，所以下一次比较的时候不用对后i个数比较了  
  11.                 int temp = nums[j];  
  12.                 if(nums[j] > nums[j+1]){  
  13.                     nums[j] = nums[j+1];  
  14.                     nums[j+1] = temp;  
  15.                 }  
  16.             }  
  17.         }  
  18.         System.out.println("冒泡排序：");  
  19.         for (int i : nums) {  
  20.             System.out.print(i+" ");  
  21.         }  
  22.     }  

不过针对上述代码还有两种优化方案。

优化1：某一趟遍历如果没有数据交换，则说明已经排好序了，因此不用再进行迭代了。用一个标记记录这个状态即可（程序如下）。
优化2：记录某次遍历时最后发生数据交换的位置，这个位置之后的数据显然已经有序，不用再排序了。因此通过记录最后发生数据交换的位置就可以确定下次循环的范围了（上面程序中" j<=len-1-i" 实现）。

    1. public void betterBubbleSort(int[] nums,int len){  
    2. boolean flag;  
    3.         flag = true;  
    4. for(int i=0;i<len-1 && flag;i++){ //一趟比较 如果上趟比较一次也没有交换，则说明后面都排好序了，不用再比较了  
    5.             flag = false;  
    6. for(int j=0;j<len-1-i;j++){ //一次比较,每次把最大值放在最后面，所以下一次比较的时候不用对后i个数比较了  
    7. int temp = nums[j];  
    8. if(nums[j] > nums[j+1]){  
    9.                     nums[j] = nums[j+1];  
    10.                     nums[j+1] = temp;  
    11.                     flag = true;  
    12.                 }  
    13.             }  
    14.         }  
    15.         System.out.println("优化后的冒泡排序：");  
    16. for (int i : nums) {  
    17.             System.out.print(i+" ");  
    18.         }  
    19.     }  

六、快速排序 QuickSort

介绍：
快速排序通常明显比同为Ο(n log n)的其他算法更快，因此常被采用，而且快排采用了分治法的思想，所以在很多笔试面试中能经常看到快排的影子。可见掌握快排的重要性。

步骤：

  1. 从数列中挑出一个元素作为基准数。
  2. 分区过程，将比基准数大的放到右边，小于或等于它的数都放到左边。
  3. 再对左右区间递归执行第二步，直至各区间只有一个数。

排序演示：

    1. /** 
    2.      * 快速排序算法 
    3.      * 快速排序采用的思想是分治思想。快速排序是找出一个元素（理论上可以随便找一个）作为基准(pivot), 
    4.      * 然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值，如此作为基准的元素调整到排序后的正确位置。 
    5.      * 递归快速排序，将其他n-1个元素也调整到排序后的正确位置。最后每个元素都是在排序后的正 确位置，排序完成。 
    6.      * 所以快速排序算法的核心算法是分区操作，即如何调整基准的位置以及调整返回基准的最终位置以便分治递归。 
    7.      * @param nums 
    8.      * @param len 
    9.      * O(NlogN) 
    10.      */  
    11. public void QuickSort(int[] nums,int len){  
    12.         Qsort(nums,0,len-1);  
    13.         System.out.println("快速排序：");  
    14. for (int k : nums) {  
    15.             System.out.print(k+" ");  
    16.         }  
    17.     }  
    18. public void Qsort(int[] nums, int left, int right) {  
    19. if(left>right) return;  
    20. int pivot = nums[left];  
    21. int i = left;  
    22. int j = right;  
    23. while(i < j){  
    24. while(nums[j] >= pivot && i<j){ //从右往左找比nums[i]小的数  
    25.                 j--;  
    26.             }  
    27.             nums[i] = nums[j]; //找到之后交换  
    28. while(nums[i] <= pivot && i<j){ //从左往右找比nums[j]大的数  
    29.                 i++;  
    30.             }  
    31.             nums[j]  = nums[i];  //找到之后交换  
    32.         }  
    33. //while执行完后，必然有 i==j   
    34.         nums[i] = pivot; //将基准数归位  
    35.         Qsort(nums, left, i-1); //递归处理左边  
    36.         Qsort(nums, i+1, right); //递归处理右边  
    37.     }  

七、归并排序 MergeSort

介绍：

归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。

先考虑合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。

再考虑递归分解，基本思路是将数组分解成left和right，如果这两个数组内部数据是有序的，那么就可以用上面合并数组的方法将这两个数组合并排序。如何让这两个数组内部是有序的？可以再二分，直至分解出的小组只含有一个元素时为止，此时认为该小组内部已有序。然后合并排序相邻二个小组即可。

排序演示：

 
  1. /** 
  2.      * 归并排序算法 
  3.      * 将待排序序列R[0...n-1]看成是n个长度为1的有序序列，将相邻的有序表成对归并，得到n/2个长度为2的有序表；将这些有序序列再次归并， 
  4.      * 得到n/4个长度为4的有序序列；如此反复进行下去，最后得到一个长度为n的有序序列。 
  5.      * 综上可知：归并排序其实要做两件事：（1）“分解”——将序列每次折半划分。（2）“合并”——将划分后的序列段两两合并后排序。 
  6.      * @param nums 
  7.      * @param len 
  8.      * O(nlogn) 
  9.      */  
  10.     public void MergeSort(int[] nums,int len){  
  11.         sort(nums, 0, len-1);  
  12.         System.out.println("归并排序：");  
  13.         for (int k : nums) {  
  14.             System.out.print(k+" ");  
  15.         }  
  16.     }  
  17.     //分段 将一个数组分成2个数组  
  18.     public void sort(int[] nums,int low,int high){  
  19.         int mid = (high+low)/2;  
  20.         if(low < high){  
  21.             sort(nums, low, mid);  
  22.             sort(nums, mid+1, high);  
  23.             merge(nums, low, mid, high);  
  24.         }  
  25.     }  
  26.     // 分段排序 再合起来  
  27.     public void merge(int[] array,int low,int mid,int high){  
  28.         int i=low; //第一段序列下标  
  29.         int j=mid+1; //第二段序列下标  
  30.         int k=0; //第三段序列下标  
  31.         int[] array2 = new int[high - low + 1]; //新序列  
  32.         while(i<=mid && j<=high){ //把两个子序列的头元素比较，取较小者进入新序列，然后在旧序列中跳过这个较小值，开始下一次比较  
  33.             if(array[i] <= array[j]){  
  34.                 array2[k++] = array[i++];  
  35.             }  
  36.             else{  
  37.                 array2[k++] = array[j++];  
  38.             }  
  39.         }  
  40.         if(i <= mid){ //说明上面是j溢出退出循环，即序列1还未比较完  
  41.             while(i<=mid){ //若第一段序列还没扫描完，将其全部复制到合并序列  
  42.                 array2[k++] = array[i++];  
  43.             }  
  44.         }  
  45.         else if(j <= high){  
  46.             while(j<=high){ //若第二段序列还没扫描完，将其全部复制到合并序列  
  47.                 array2[k++] = array[j++];  
  48.             }  
  49.         }  
  50.         for(k=0;k<array2.length;k++){  
  51.             array[k+low] = array2[k];//将分段排序的新数组复制到之前数组  
  52.         }  
  53.     }  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/barrywxx/p/8596272.html