选择、插入、归并、希尔、快速排序算法性能比较总结

1 概述

    本文对比较常用且比较高效的排序算法进行了总结和解析,并贴出了比较精简的实现代码,包括选择排序、插入排序、归并排序、希尔排序、快速排序等。算法性能比较如下图所示:


2 选择排序
选择排序的第一趟处理是从数据序列所有n个数据中选择一个最小的数据作为有序序列中的第1个元素并将它定位在第一号存储位置,第二趟处理从数据序列的n-1个数据中选择一个第二小的元素作为有序序列中的第2个元素并将它定位在第二号存储位置,依此类推,当第n-1趟处理从数据序列的剩下的2个元素中选择一个较小的元素作为有序序列中的最后第2个元素并将它定位在倒数第二号存储位置,至此,整个的排序处理过程就已完成。
代码如下:
  1. public class SelectionSort {
  2.     public void selectionSort(int[] array) {
  3.         int temp;
  4.         for (int i = 0; i < array.length - 1; i++) {
  5.             for (int j = i + 1; j <= array.length - 1; j++) {// 第i个和第j个比较j可以取到最后一位,所以要用j<=array.length-1
  6.                 if (array[i] > array[j]) {// 注意和冒泡排序的区别,这里是i和j比较。
  7.                     temp = array[i];
  8.                     array[i] = array[j];
  9.                     array[j] = temp;
  10.                 }
  11.             }
  12.             // 打印每趟排序结果
  13.             for (int m = 0; m <= array.length - 1; m++) {
  14.                 System.out.print(array[m] + "\t");
  15.             }
  16.             System.out.println();
  17.         }
  18.     }

  19.     public static void main(String[] args) {
  20.         SelectionSort selectionSort = new SelectionSort();
  21.         int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
  22.         selectionSort.selectionSort(array);
  23.         for (int m = 0; m <= array.length - 1; m++) {
  24.             System.out.print(array[m] + "\t");
  25.         }
  26.     }
  27. }
复制代码

3 插入排序
直接插入排序法的排序原则是:将一组无序的数字排列成一排,左端第一个数字为已经完成排序的数字,其他数字为未排序的数字。然后从左到右依次将未排序的数字插入到已排序的数字中。
代码如下:
  1. public class InsertSort {
  2.     public void insertSort(int[] array, int first, int last) {
  3.         int temp, i, j;
  4.         for (i = first + 1; i <= last - 1; i++) {// 默认以第一个数为有序序列,后面的数为要插入的数。
  5.             temp = array[i];
  6.             j = i - 1;
  7.             while (j >= first && array[j] > temp) {// 从后进行搜索如果搜索到的数小于temp则该数后移继续搜索,直到搜索到小于或等于temp的数即可
  8.                 array[j + 1] = array[j];
  9.                 j--;
  10.             }
  11.             array[j + 1] = temp;
  12.             // 打印每次排序结果
  13.             for (int m = 0; m <= array.length - 1; m++) {
  14.                 System.out.print(array[m] + "\t");
  15.             }
  16.             System.out.println();
  17.         }
  18.     }

  19.     public static void main(String[] args) {
  20.         InsertSort insertSort = new InsertSort();
  21.         int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
  22.         insertSort.insertSort(array, 0, array.length);// 注意此处是0-9而不是0-8
  23.         for (int i = 0; i <= array.length - 1; i++) {
  24.             System.out.print(array[i] + "\t");
  25.         }
  26.     }
  27. }
复制代码

4 归并排序
算法描述:
把序列分成元素尽可能相等的两半。
把两半元素分别进行排序。
把两个有序表合并成一个。
代码如下:
  1. public class MergeSortTest {
  2.     public void sort(int[] array, int left, int right) {
  3.         if (left >= right)
  4.             return;
  5.         // 找出中间索引
  6.         int center = (left + right) / 2;
  7.         // 对左边数组进行递归
  8.         sort(array, left, center);
  9.         // 对右边数组进行递归
  10.         sort(array, center + 1, right);
  11.         // 合并
  12.         merge(array, left, center, right);
  13.         // 打印每次排序结果
  14.         for (int i = 0; i < array.length; i++) {
  15.             System.out.print(array[i] + "\t");
  16.         }
  17.         System.out.println();

  18.     }

  19.     /**
  20.      * 将两个数组进行归并,归并前面2个数组已有序,归并后依然有序
  21.      * 
  22.      * @param array
  23.      *            数组对象
  24.      * @param left
  25.      *            左数组的第一个元素的索引
  26.      * @param center
  27.      *            左数组的最后一个元素的索引,center+1是右数组第一个元素的索引
  28.      * @param right
  29.      *            右数组最后一个元素的索引
  30.      */
  31.     public void merge(int[] array, int left, int center, int right) {
  32.         // 临时数组
  33.         int[] tmpArr = new int[array.length];
  34.         // 右数组第一个元素索引
  35.         int mid = center + 1;
  36.         // third 记录临时数组的索引
  37.         int third = left;
  38.         // 缓存左数组第一个元素的索引
  39.         int tmp = left;
  40.         while (left <= center && mid <= right) {
  41.             // 从两个数组中取出最小的放入临时数组
  42.             if (array[left] <= array[mid]) {
  43.                 tmpArr[third++] = array[left++];
  44.             } else {
  45.                 tmpArr[third++] = array[mid++];
  46.             }
  47.         }
  48.         // 剩余部分依次放入临时数组(实际上两个while只会执行其中一个)
  49.         while (mid <= right) {
  50.             tmpArr[third++] = array[mid++];
  51.         }
  52.         while (left <= center) {
  53.             tmpArr[third++] = array[left++];
  54.         }
  55.         // 将临时数组中的内容拷贝回原数组中
  56.         // (原left-right范围的内容被复制回原数组)
  57.         while (tmp <= right) {
  58.             array[tmp] = tmpArr[tmp++];
  59.         }
  60.     }

  61.     public static void main(String[] args) {
  62.         int[] array = new int[] { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
  63.         MergeSortTest mergeSortTest = new MergeSortTest();
  64.         mergeSortTest.sort(array, 0, array.length - 1);
  65.         System.out.println("排序后的数组:");
  66.         for (int m = 0; m <= array.length - 1; m++) {
  67.             System.out.print(array[m] + "\t");
  68.         }
  69.     }
  70. }
复制代码

5 希尔排序
希尔排序又称“缩小增量排序”,该方法的基本思想是:先将整个待排元素序列分割成若干个子序列(由相隔某 个“增量”的元素组成的)分别进行直接插入排序,然后依次缩减增量再进行排序,待整个序列中的元素基本有序(增量足够小)时,再对全体元素进行一次直接插 入排序。因为直接插入排序在元素基本有序的情况下(接近最好情况),效率是很高的,因此希尔排序在时间效率上比前两种方法有较大提高。
代码如下:
  1. public class ShellSort {
  2.     public void shellSort(int[] array, int n) {
  3.         int i, j, gap;
  4.         int temp;
  5.         for (gap = n / 2; gap > 0; gap /= 2) {// 计算gap大小
  6.             for (i = gap; i < n; i++) {// 将数据进行分组
  7.                 for (j = i - gap; j >= 0 && array[j] > array[j + gap]; j -= gap) {// 对每组数据进行插入排序
  8.                     temp = array[j];
  9.                     array[j] = array[j + gap];
  10.                     array[j + gap] = temp;
  11.                 }
  12.                 // 打印每趟排序结果
  13.                 for (int m = 0; m <= array.length - 1; m++) {
  14.                     System.out.print(array[m] + "\t");
  15.                 }
  16.                 System.out.println();
  17.             }
  18.         }
  19.     }

  20.     public static void main(String[] args) {
  21.         ShellSort shellSort = new ShellSort();
  22.         int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
  23.         shellSort.shellSort(array, array.length);// 注意为数组的个数
  24.         for (int m = 0; m <= array.length - 1; m++) {
  25.             System.out.print(array[m] + "\t");
  26.         }
  27.     }
  28. }
复制代码

6 快速排序
快速排序(Quicksort)是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然 后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
代码如下:
  1. <font size="3"><pre class="brush: csharp; gutter: false; first-line: 1">public class QuickSort {
  2.     public int partition(int[] sortArray, int low, int height) {
  3.         int key = sortArray[low];// 刚开始以第一个数为标志数据
  4.         while (low < height) {
  5.             while (low < height && sortArray[height] >= key)
  6.                 height--;// 从后面开始找,找到比key值小的数为止
  7.             sortArray[low] = sortArray[height];// 将该数放到key值的左边
  8.             while (low < height && sortArray[low] <= key)
  9.                 low++;// 从前面开始找,找到比key值大的数为止
  10.             sortArray[height] = sortArray[low];// 将该数放到key值的右边
  11.         }
  12.         sortArray[low] = key;// 把key值填充到low位置,下次重新找key值
  13.         // 打印每次排序结果
  14.         for (int i = 0; i <= sortArray.length - 1; i++) {
  15.             System.out.print(sortArray[i] + "\t");
  16.         }
  17.         System.out.println();
  18.         return low;
  19.     }

  20.     public void sort(int[] sortArray, int low, int height) {
  21.         if (low < height) {
  22.             int result = partition(sortArray, low, height);
  23.             sort(sortArray, low, result - 1);
  24.             sort(sortArray, result + 1, height);
  25.         }
  26.     }

  27.     public static void main(String[] args) {
  28.         QuickSort quickSort = new QuickSort();
  29.         int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
  30.         for (int i = 0; i <= array.length - 1; i++) {
  31.             System.out.print(array[i] + "\t");
  32.         }
  33.         System.out.println();
  34.         quickSort.sort(array, 0, 8);
  35.         for (int i = 0; i <= array.length - 1; i++) {
  36.             System.out.print(array[i] + "\t");
  37.         }
  38.     }
  39. }</pre></font><pre class="brush: csharp; gutter: false; first-line: 1"></pre>
复制代码 文章来源: http://www.mfqyw.com/


  • 2
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值