Java常用排序算法及性能测试集合
测试报告：
Array length: 20000 bubbleSort : 573 ms bubbleSortAdvanced : 596 ms bubbleSortAdvanced2 : 583 ms selectSort : 160 ms insertSort : 76 ms insertSortAdvanced : 59 ms insertSortAdvanced2 : 164 ms binaryTreeSort : 3 ms shellSort : 2 ms shellSortAdvanced : 2 ms shellSortAdvanced2 : 1 ms mergeSort : 3 ms quickSort : 1 ms heapSort : 2 ms
通过测试，可以认为，冒泡排序完全有理由扔进垃圾桶。它存在的唯一理由可能是最好理解。希尔排序的高效性是我没有想到的；堆排序比较难理解和编写，要有宏观的思维。
/* * SortUtil.java * Version 1.0.0 * Created on 2017年9月3日 * Copyright ReYo.Cn */ package reyo.sdk.utils.test.sort; /** * <B>创 建 人：</B>AdministratorReyoAut <BR> * <B>创建时间：</B>2017年9月3日 上午7:41:36<BR> * * @author ReYo * @version 1.0 */ import java.lang.reflect.Method; import java.util.Arrays; import java.util.Date; /** * Java常用排序算法及性能测试集合 * * 本程序集合涵盖常用排序算法的编写，并在注释中配合极其简单的特例讲解了各种算法的工作原理，以方便理解和吸收； * 程序编写过程中吸收了很多维基百科和别人blog上面的例子，并结合自己的思考，选择或改进一个最容易让人理解的写法。 */ public class SortUtil { // 被测试的方法集合 static String[] methodNames = new String[] { "bubbleSort", "bubbleSortAdvanced", "bubbleSortAdvanced2", "selectSort", "insertSort", "insertSortAdvanced", "insertSortAdvanced2", "binaryTreeSort", "shellSort", "shellSortAdvanced", "shellSortAdvanced2", "mergeSort", "quickSort", "heapSort" }; public static void main(String[] args) throws Exception { //correctnessTest(); performanceTest(20000); } /** * 正确性测试<br> * 简单地测试一下各个算法的正确性<br> * 只是为了方便观测新添加的算法是否基本正确；<br> * @throws Exception 主要是反射相关的Exception；<br> */ public static void correctnessTest() throws Exception { int len = 10; int[] a = new int[len]; for (int i = 0; i < methodNames.length; i++) { for (int j = 0; j < a.length; j++) { a[j] = (int) Math.floor(Math.random() * len * 2); } Method sortMethod = null; sortMethod = SortUtil.class.getDeclaredMethod(methodNames[i], a.getClass()); Object o = sortMethod.invoke(null, a); System.out.print(methodNames[i] + " : "); if (o == null) { System.out.println(Arrays.toString(a)); } else { //兼顾mergeSort，它的排序结果以返回值的形式出现； System.out.println(Arrays.toString((int[]) o)); } } } /** * 性能测试<br> * 数组长度用参数len传入，每个方法跑20遍取耗时平均值；<br> * @param len 数组长度 建议取10000以上，否则有些算法会显示耗时为0；<br> * @throws Exception 主要是反射相关的Exception；<br> */ public static void performanceTest(int len) throws Exception { int[] a = new int[len]; int times = 20; System.out.println("Array length: " + a.length); for (int i = 0; i < methodNames.length; i++) { Method sortMethod = null; sortMethod = SortUtil.class.getDeclaredMethod(methodNames[i], a.getClass()); int totalTime = 0; for (int j = 0; j < times; j++) { for (int k = 0; k < len; k++) { a[k] = (int) Math.floor(Math.random() * 20000); } long start = new Date().getTime(); sortMethod.invoke(null, a); long end = new Date().getTime(); totalTime += (end - start); } System.out.println(methodNames[i] + " : " + (totalTime / times) + " ms"); //System.out.println(Arrays.toString(a)); } } /** * 最原始的冒泡交换排序;<br> * 两层遍历，外层控制扫描的次数，内层控制比较的次数；<br> * 外层每扫描一次，就有一个最大的元素沉底；所以内层的比较次数将逐渐减小；<br> * 时间复杂度: 平均:O(n^2)，最好:O(n);最坏:O(n^2); * 空间复杂度: O(1); */ public static void bubbleSort(int[] a) { for (int i = 0; i < a.length; i++) { for (int j = 0; j < a.length - i - 1; j++) { if (a[j] > a[j + 1]) { int tmp = a[j]; a[j] = a[j + 1]; a[j + 1] = tmp; } } } } /** * 改进的冒泡法<br> * 改进之处在于：设一个标志位，如果某趟跑下来，没有发生交换，说明已经排好了；<br> */ public static void bubbleSortAdvanced(int[] a) { int k = a.length - 1; boolean flag = true; while (flag) { flag = false; for (int i = 0; i < k; i++) { if (a[i] > a[i + 1]) { int tmp = a[i]; a[i] = a[i + 1]; a[i + 1] = tmp; //有交换则继续保持标志位； flag = true; } } k--; } } /** * 改进的冒泡法2<br> * 改进之处在于吸收上面的思想(没有交换意味着已经有序)，如果局部的已经是有序的，则后续的比较就不需要再比较他们了。<br> * 比如：3142 5678，假如刚刚做完了2和4交换之后，发现这趟比较后续再也没有发生交换，则后续的比较只需要比到4即可；<br> * 该算法就是用一个标志位记录某趟最后发生比较的地点；<br> */ public static void bubbleSortAdvanced2(int[] a) { int flag = a.length - 1; int k; while (flag > 0) { k = flag; flag = 0; for (int i = 0; i < k; i++) { if (a[i] > a[i + 1]) { int tmp = a[i]; a[i] = a[i + 1]; a[i + 1] = tmp; //有交换则记录该趟最后发生比较的地点； flag = i + 1; } } } } /** * 插入排序 * * 关于插入排序，这里有几个约定，从而可以快速理解算法：<br> * i: 无序表遍历下标；i<n-1；<br> * j: 有序表遍历下表；0<=j<i;<br> * a[i]:表示当前被拿出来做插入排序的无序表头元素；<br> * a[j]:有序表中的任意元素；<br> * <br> * 算法关键点：把数组分割为a[0~i-1]有序表，a[i~n-1]无序表；每次从无序表头部取一个，<br> * 把它插入到有序表适当的位置，直到无序表为空；<br> * 初始时，a[0]为有序表，a[1~n-1]为无序表；<br> * * 时间复杂度: 平均:O(n^2)，最好:O(n);最坏:O(n^2); * 空间复杂度: O(1); */ public static void insertSort(int[] a) { //从无序表头开始遍历； for (int i = 1; i < a.length; i++) { int j; //拿a[i]和有序表元素依次比较，找到一个恰当的位置； for (j = i - 1; j >= 0; j--) { if (a[j] < a[i]) { break; } } //如果找到恰当的位置，则从该位置开始，把元素朝后移动一格，为插入的元素腾出空间； if (j != (i - 1)) { int tmp = a[i]; int k; for (k = i - 1; k > j; k--) { a[k + 1] = a[k]; } a[k + 1] = tmp; } } } /** * 改进的插入排序1 * 改进的关键在于：首先拿无序表头元素a[i]和有序表尾a[i-1]比较， * 如果a[i]<a[i-1],说明需要调整；调整的过程为： * 从有序表尾开始，把有序表里面比a[i]大的元素都朝后移动，直到找到恰当的位置； */ public static void insertSortAdvanced(int[] a) { //遍历无序表； for (int i = 1; i < a.length; i++) { //如果无序表头元素小于有序表尾，说明需要调整； if (a[i] < a[i - 1]) { int tmp = a[i]; int j; //从有序表尾朝前搜索并比较，并把大于a[i]的元素朝后移动以腾出空间； for (j = i - 1; j >= 0 && a[j] > tmp; j--) { a[j + 1] = a[j]; } a[j + 1] = tmp; } } } /** * 改进的插入排序2 * 总体思想和上面相似，拿无序表头元素从有序表尾元素开始朝前比较， * 如果a[i]比a[i-1]小，则把a[i]从有序表尾用冒泡交换的方式朝前移动，直到到达恰当的位置； */ public static void insertSortAdvanced2(int[] a) { //遍历无序表 for (int i = 1; i < a.length; i++) { //拿a[i]从有序表尾开始冒泡； for (int j = i - 1; j >= 0 && a[j] > a[j + 1]; j--) {//a[j+1]就是a[i] int tmp = a[j]; a[j] = a[j + 1]; a[j + 1] = tmp; } } } /** * 快速排序<br> * 算法的思想在于分而治之:先找一个元素(一般来说都是数组头元素),把比它大的都放到右边,把比它小的都放到左边;<br> * 然后再按照这样的思想去处理两个子数组; 下面说的子数组头元素通指用来划分数组的元素;<br> * <br> * 下面程序关键点就在于!forward, low0++, high0--这些运算; 这三个运算使得a[low0],a[high0]里面总有一个指向子数组头元素; <br> * 可以用极端的情况来方便理解这三个值的运作: <br> * 假如我的数列为0123456789, 初始时forward=false,0作为子数组划分依据,很显然第一轮的时候不会发生任何交换,low0一直指向0,<br> * high0逐渐下降直到它指向0为止; 同理可思考9876543210这个例子;<br> * <br> * 时间复杂度: 平均:O(nlogn)，最好:O(nlogn);最坏:O(n^2); * 空间复杂度: O(logn);要为递归栈提供空间 * @param a 待排序数组<br> * @param low 子数组开始的下标;<br> * @param high 子数组结束的下标;<br> */ public static void quickSort(int[] a, int low, int high) { if (low >= high) { return; } int low0 = low; int high0 = high; boolean forward = false; while (low0 != high0) { if (a[low0] > a[high0]) { int tmp = a[low0]; a[low0] = a[high0]; a[high0] = tmp; forward = !forward; } if (forward) { low0++; } else { high0--; } } low0--; high0++; quickSort(a, low, low0); quickSort(a, high0, high); } /** * 快速排序的简单调用形式<br> * 方便测试和调用<br> * @param a */ public static void quickSort(int[] a) { quickSort(a, 0, a.length - 1); } /** * 归并排序<br> * 所谓归并，就是合并两个有序数组；归并排序也用了分而治之的思想，把一个数组分为若干个子数组；<br> * 当子数组的长度为1的时候，则子数组是有序的，于是就可以两两归并了；<br> * <br> * 由于归并排序需要分配空间来转储归并的结果，为了算法上的方便，归并算法的结果以返回值的形式出现；<br> */ /** * 合并两个有序数组 * @param a 有序数组1 * @param b 有序数组2 * @return 合并之后的有序数组； */ public static int[] merge(int[] a, int[] b) { int result[] = new int[a.length + b.length]; int i = 0, j = 0, k = 0; while (i < a.length && j < b.length) { if (a[i] < b[j]) { result[k++] = a[i]; i++; } else { result[k++] = b[j]; j++; } } while (i < a.length) { result[k++] = a[i++]; } while (j < b.length) { result[k++] = b[j++]; } return result; } /** * 归并排序<br> * 把数组从中间一分为二，并对左右两部分递归调用，直到数组长度为1的时候，开始两两归并；<br> * 时间复杂度: 平均:O(nlogn)，最好:O(nlogn);最坏:O(nlogn); * 空间复杂度: O(n);要为归并的结果分配空间 * @param 待排序数组； * @return 有序数组； */ public static int[] mergeSort(int[] a) { if (a.length == 1) { return a; } int mid = a.length / 2; int[] leftPart = new int[mid]; int[] rightPart = new int[a.length - mid]; System.arraycopy(a, 0, leftPart, 0, leftPart.length); System.arraycopy(a, mid, rightPart, 0, rightPart.length); leftPart = mergeSort(leftPart); rightPart = mergeSort(rightPart); return merge(leftPart, rightPart); } /** * 选择排序<br> * 和插入排序类似，它也把数组分割为有序区和无序区，所不同的是：<br> * 插入排序是拿无序区的首元素插入到有序区适当的位置，而<br> * 选择排序是从无序区中挑选最小的放到有序区最后；<br> * <br> * 两层循环，外层控制有序区的队尾，内层用来查找无序区最小元素；<br> * * 时间复杂度: 平均:O(n^2)，最好:O(n);最坏:O(n^2); * 空间复杂度: O(1); * @param a */ public static void selectSort(int[] a) { for (int i = 0; i < a.length; i++) { int minIndex = i; for (int j = i + 1; j < a.length; j++) { if (a[j] < a[minIndex]) { minIndex = j; } } int tmp = a[i]; a[i] = a[minIndex]; a[minIndex] = tmp; } } /** * 希尔排序<br> * 其思想是把数组按等步长(/间距)划分为多个子序列，对各个子序列做普通的插入排序，<br>逐次降低步长，直到为1的时候最后再做一次普通的插入排序； * 用一个极端的例子作比方，我有数列如下：<br> * [1,2,3,4,5,6,7,8,9,10];<br> * 初始的时候，步长gap=5；则划分的子数组为[1,6], [2,7], [3,8], [4,9], [5,10];<br>对他们分别排序(当然由于本数组特殊，所以结果是不变的)；<br> * 然后gap=2=5/2; 子数组为[1,3,5,7,9], [2,4,6,8,10]; <br> * 最后gap=1=2/2; 做一次全局排序；<br> * <br> * 希尔排序克服了插入/冒泡排序的弱点(一次只能把元素移动一个相邻的位置), <br>依靠大步长，可以把元素尽快移动到目标位置(或附近);<br> * 希尔排序实际上是插入排序的变种。它适用于：当数组总体有序，个别需要调整的情况；这时候利用插入排序的优势，可以达到O(n)的效率；<br> * 影响希尔算法的一个重要的因素是步长选择，一个好步长的优点是：后面的短步长排序不会破坏前面的长步长排序；<br> * 怎么理解这种破坏呢？前面的长步长把一个较小的数移到了左面，但是在缩小步长之后有可能又被交换到了右面 (因为它被分到了一个有很多比它更小的组)；<br> * 关于步长，可以查看http://zh.wikipedia.org上面关于希尔排序的页面；<br> * 下面的程序是希尔排序最基础的写法，适合用来理解希尔排序思想；<br> * * 时间复杂度： 受步长影响较大，n/2步长的平均复杂度为n(logn)^2; */ public static void shellSort(int[] a) { // 控制间距；间距逐渐减小，直到为1； for (int gap = a.length / 2; gap > 0; gap /= 2) { // 扫描每个子数组 for (int i = 0; i < gap; i++) { // 对每个字数组，扫描无序区；注意增量； // a[i]是初始有序区； for (int j = i + gap; j < a.length; j += gap) { // 无序区首元素小于有序区尾元素，说明需要调整 if (a[j] < a[j - gap]) { int tmp = a[j]; int k = j - gap; //从有序区尾向前搜索查找适当的位置； while (k >= 0 && a[k] > tmp) { a[k + gap] = a[k]; k -= gap; } a[k + gap] = tmp; } } } } } /** * 改进的希尔排序<br> * 改进之处在于：上面的写法用一个for循环来区别对待每个字数组；而实际上是不必要的；<br> * a[0,1,...gap-1]作为所有子数组的有序区，a[gap,...n-1]作为所有字数组的无序区；<br> * <br> * 该改进在时间效率上没有改进；只是让程序看起来更简洁；<br> * @param a */ public static void shellSortAdvanced(int[] a) { // 控制步长 for (int gap = a.length / 2; gap > 0; gap /= 2) { // 从无序区开始处理，把多个子数组放在一起处理； for (int j = gap; j < a.length; j++) { // 下面的逻辑和上面是一样的； if (a[j] < a[j - gap]) { int tmp = a[j]; int k = j - gap; while (k >= 0 && a[k] > tmp) { a[k + gap] = a[k]; k -= gap; } a[k + gap] = tmp; } } } } /** * 改进的希尔排序2<br> * 在吸收shellSortAdvanced思想的基础上，采用insertAdvanced2的做法；<br>即无序区首元素通过朝前冒泡的形式移动的适当的位置；<br> * @param a */ public static void shellSortAdvanced2(int[] a) { for (int gap = a.length / 2; gap > 0; gap /= 2) { for (int i = gap; i < a.length; i++) { if (a[i] < a[i - gap]) { for (int j = i - gap; j >= 0 && a[j + gap] > a[j]; j -= gap) { int tmp = a[j]; a[j] = a[j + gap]; a[j + gap] = tmp; } } } } } /** * 堆排序<br> * 堆的定义：堆是一个完全，或近似完全的二叉树，堆顶元素的值大于左右孩子的值，左右孩子也需要满足这个条件；<br> * 按照堆的定义，堆可以是大顶堆(maxHeap)，或小顶堆(minHeap)；<br> * 一般用数组即可模拟二叉树，对于任意元素i，左孩子为2*i+1,右孩子为2*i+2;父节点为(i-1)/2; * * 时间复杂度: 平均:O(nlogn); * 空间复杂度: O(1); * @param a */ public static void heapSort(int[] a) { // 先从最后一个非叶子节点往上调整，使满足堆结构； for (int i = (a.length - 2) / 2; i >= 0; i--) { maxHeapAdjust(a, i, a.length); } // 每次拿最后一个节点和第一个交换，然后调整堆；直到堆顶； for (int i = a.length - 1; i > 0; i--) { int tmp = a[i]; a[i] = a[0]; a[0] = tmp; maxHeapAdjust(a, 0, i); } } /** * 调整堆<br> * 把以i为跟节点的二叉树调整为堆；<br> * 可以这么来思考这个过程：这个完全二叉树就像一个金字塔，塔顶的小元素沿着树结构，往下沉降；<br> * 调整的结果是最大的元素在金字塔顶，然后把它从堆中删除(把它交换到堆尾，然后堆收缩一格)；<br> * 堆排序快的原因就是根据二叉树的特点，一个节点要沉降到合适的位置，只需要logn步；同时前期调整的结果(大小顺序)会被记录下来，从而加快后续的调整；<br> * @param a 待排数组 * @param i 堆顶 * @param len 堆长度 */ public static void maxHeapAdjust(int[] a, int i, int len) { int tmp = a[i]; // j是左孩子节点 int j = i * 2 + 1; // while (j < len) { // 从左右孩子中挑选大的 // j+1是右孩子节点 if ((j + 1) < len && a[j + 1] > a[j]) { j++; } // 找到恰当的位置就不再找 if (a[j] < tmp) { break; } // 否则把较大者沿着树往上移动； a[i] = a[j]; // i指向刚才的较大的孩子； i = j; // j指向新的左孩子节点； j = 2 * i + 1; } // 把要调整的节点值下沉到适当的位置； a[i] = tmp; } /** * 二叉树排序<br> * 二叉树的定义是嵌套的：<br>节点的值大于左叶子节点的值，小于右叶子节点的值；叶子节点同样满足这个要求；<br> * 二叉树的构造过程就是排序的过程：<br> * 先构造跟节点，然后调用add方法添加后续节点为跟节点的子孙节点；这个过程也是嵌套的;<br> * <br> * 中序遍历二叉树即得到有序结果；<br> * 二叉树排序用法特殊，使用情形要视情况而定；<br> * * 时间复杂度: 平均:O(nlogn); * 空间复杂度: O(n); * * @param a */ public static void binaryTreeSort(int[] a) { // 构造一个二叉树节点内部类来实现二叉树排序算法； class BinaryNode { int value; BinaryNode left; BinaryNode right; public BinaryNode(int value) { this.value = value; this.left = null; this.right = null; } public void add(int value) { if (value > this.value) { if (this.right != null) { this.right.add(value); } else { this.right = new BinaryNode(value); } } else { if (this.left != null) { this.left.add(value); } else { this.left = new BinaryNode(value); } } } /** * 按中序遍历二叉树，就是有序的。 */ public void iterate() { if (this.left != null) { this.left.iterate(); } // 在测试的时候要把输出关掉，以免影响性能； // System.out.print(value + ", "); if (this.right != null) { this.right.iterate(); } } } BinaryNode root = new BinaryNode(a[0]); for (int i = 1; i < a.length; i++) { root.add(a[i]); } root.iterate(); } }
各排序算法的性能比较
|
排序方法 |
最好时间复杂度 |
平均时间复杂度 |
最坏时间复杂度 |
空间复杂度 |
稳定性 |
|
插入排序 |
O(n) |
O(n^2) |
O(n^2) |
O(1) |
稳定 |
|
希尔排序 |
|
O(n^1.3) |
|
O(1) |
不稳定 |
|
选择排序 |
O(n^2) |
O(n^2) |
O(n^2) |
O(1) |
稳定 |
|
堆排序 |
O(nlbn) |
O(nlbn) |
O(nlbn) |
O(1) |
不稳定 |
|
冒泡排序 |
O(n) |
O(n^2) |
O(n^2) |
O(1) |
稳定 |
|
快速排序 |
O(nlbn) |
O(nlbn) |
O(n^2) |
O(lbn) |
不稳定 |
|
归并排序 |
O(nlbn) |
O(nlbn) |
O(nlbn) |
O(n) |
稳定 |
|
基数排序 |
O(m*n) |
O(m*n) |
O(m*n) |
O(n) |
稳定 |
