常用排序算法总结及源码

排序算法是在算法学习中最基本的，也是平时最常用的。这里贴出我总结出来的常用算法。

先写一个基础抽象类，所有排序类都继承自该类，sort方法就是具体排序算法的实现：

public abstract class BaseSorter<E extends Comparable<E>> {public abstract void sort(E[] array);protected final void swap(E[] array, int from, int to) {E temp = array[from];array[from] = array[to];array[to] = temp;}}

1、插入排序

插入排序，对于较小的数组时，该方法十分的高效。

最差时间复杂度O(n2)，最优时间复杂度O(n)，平均时间复杂度O(n2)，最差空间复杂度O(n)，辅助空间O(1)。

需要辅助空间复杂度O(1)

public class InsertSorter<E extends Comparable<E>> extends BaseSorter<E> {@Overridepublic void sort(E[] array) {for (int i = 1; i < array.length; i++) {E temp = array[i];int j = i;for (; j > 0 && array[j - 1].compareTo(temp) > 0; j--) {array[j] = array[j - 1];}array[j] = temp;}// //下面这个代码方便不过交换次数增多，影响性能//for (int i = 1; i < array.length; i++) //for (int j = i; j > 0 && array[j - 1].compareTo(array[j]) > 0; j--) //swap(array, j - 1, j); }}

插入排序的过程效果图：

下面是一个数组使用插入排序的过程示例，通过这个能很清楚数组整个过程的排序步骤：

2、冒泡排序

冒泡排序的算法思想很简单，同时效率低。冒泡排序与插入排序拥有相等的执行时间，但两种方法需要交换的次数却很大的不同。

冒泡排序的时间复杂度空间复杂度和插入排序一样。

在最坏的情况冒泡需要O(n2)次交换，而插入只需要O(n)次交换。因此很多地方避免使用冒泡而使用插入替代。

public class BubbleSorter<E extends Comparable<E>> extends BaseSorter<E> {@Overridepublic void sort(E[] array) {for (int i = array.length - 1; i > 0; i--)for (int j = 0; j < i; j++) {if (array[j].compareTo(array[j + 1]) > 0)swap(array, j, j + 1);}}}

冒泡排序的过程效果图：

3、选择排序

选择排序，先在未排列序列中找到最小（大）元素，存放到排列序列起始位置，然后从剩余未排列序列中继续找到最小（大）元素存放到排列序列末尾。以此类推，直到全部排列完成。

对于n个元素的表进行排序总共最多进行n-1次交换。

最差时间复杂度O(n2)，最优时间复杂度O(n2)，平均时间复杂度O(n2)，最差空间复杂度O(n)，辅助空间O(1)

public class SelectSorter<E extends Comparable<E>> extends BaseSorter<E> {@Overridepublic void sort(E[] array) {for (int i = 0; i < array.length; i++) {int min = i;for (int j = i+1; j<array.length; j++) {if(array[j].compareTo(array[min]) < 0) { min = j; }}// 查找最小的if(min != i) swap(array, min, i);}}}

选择排序的过程图：

4、希尔排序

希尔排序是插入排序的一种高速而稳定的改进版。由于插入排序的特点：对几乎已经排好序的序列操作时非常高效。因此提出把数据分为若个小块，分别使用插入排序，之后再合并继续插入排序，依次递归直到整个序列都变为有序。

步长的选择是希尔排序的重要部分，先以一定步长排序，再以更小的步长进行排序，最终以步长为1进行排序。下面的代码是使用步长取半的方法，但并不是最好的取步长的方法。

时间复杂度根据取步长的方法而不同，

public class ShellSorter<E extends Comparable<E>> extends BaseSorter<E> {@Overridepublic void sort(E[] array) {int value = 1;while ((value + 1) * 2 < array.length)value = (value + 1) * 2 - 1;for (int n = value; n >= 1; n = (n + 1) / 2 - 1) shellSort(array, n);}private void shellSort(E[] array, int n) {for (int i = n; i < array.length; i+=n) {E tmp = array[i];int j = i;for (; j > 0 && array[j - n].compareTo(tmp) > 0; j -= n)array[j] = array[j - n];array[j] = tmp;}}}

希尔排序的过程图：

5、快速排序

对于数据比较多的使用快速排序效率是很高的，快排也是目前使用中会用到最多的一种排序算法。

快速排序是不稳定的，最差的时候时间度最长，递归的层数就是最大(最差时间复杂度O(n2)，这种情况不多)。Java中递归过多层次，有可能会引起栈溢出！

最差时间复杂度O(n2)，最优时间复杂度O(n log n)，平均时间复杂度O(n log n)

public class QuickSorter<E extends Comparable<E>> extends BaseSorter<E> {@Overridepublic void sort(E[] array) {quickSort(array, 0, array.length - 1);}private void quickSort(E[] array, int low, int high) {if (high - low < 1)return;int i = low;int j = high;E temp = array[low];while (i != j) {// 找到右边数第一个小于枢纽元素的元素while (i < j && array[j].compareTo(temp) > 0)j--;if (i < j) {array[i] = array[j]; i++;}// 找到左边数起第一个大于枢纽元素的元素while (i < j && array[i].compareTo(temp) <= 0)i++;if (i < j) {array[j] = array[i]; j--;}}// 枢纽元素移到正确位置array[i] = temp;quickSort(array, low, i- 1);quickSort(array, i+ 1, high);}}

快速排序的过程图：

6、归并排序

归并排序，将两个已经排好序的序列合并成一个序列的操作。

最差时间复杂度O(nlogn)，最优时间复杂度O(n)，平均时间复杂度O(nlogn)，最差空间复杂度O(n)

public class MergeSorter<E extends Comparable<E>> extends BaseSorter<E> {@Override@SuppressWarnings("unchecked")public void sort(E[] array) {Object[] tmp = new Comparable[array.length];mergeSort(array, 0, array.length - 1, (E[]) tmp);}private void mergeSort(E[] array, int left, int right, E[] tmp) {if (left < right) {int mid = (left + right) / 2;mergeSort(array, left, mid, tmp);mergeSort(array, mid + 1, right, tmp);merge(array, tmp, left, mid + 1, right);}}private void merge(E[] array, E[] tmp, int lPos, int rPos, int rEnd) {int lEnd = rPos - 1;int tPos = lPos; //tmp positionint lPosInit = lPos;while (lPos <= lEnd && rPos <= rEnd) {if (array[lPos].compareTo(array[rPos]) <= 0)tmp[tPos++] = array[lPos++];elsetmp[tPos++] = array[rPos++];}while (lPos <= lEnd)tmp[tPos++] = array[lPos++];while (rPos <= rEnd)tmp[tPos++] = array[rPos++];// 将排好序的临时数组中放回源数组for (; rEnd >= lPosInit; rEnd--)array[rEnd] = tmp[rEnd];}}

归并排序的过程图：

7、堆排序

堆排序时利用堆这种近似完全二叉树的数据结果来实现的。

堆结构的特点： 在起始数组为0时： * 父节点i的左子节点位置(2*i+1) * 父节点i的右子节点位置(2*i+2) * 子节点i的父节点位置((i-1)/2)

public class HeapSorter<E extends Comparable<E>> extends BaseSorter<E> {@Overridepublic void sort(E[] array) {buildMaxHeapify(array); heapSort(array);}/** * 从最后一个父节点开始依次构建最大堆 */private void buildMaxHeapify(E[] data) {int startIndex = getParentIndex(data.length - 1);for (int i = startIndex; i >= 0; i--)maxHeapify(data, data.length, i);}/** * 创建最大堆 * @param data 原数组 * @param heapSize 需要创建的最大堆的大小 * @param index 当前需要创建最大堆的位置 */private void maxHeapify(E[] data, int heapSize, int index) {// 当前点于左右子节点比较int left = getChildLeftIndex(index);int right = getChildRightIndex(index);int largest = index;if (left < heapSize && data[left].compareTo(data[index]) > 0)largest = left;if (right < heapSize && data[right].compareTo(data[largest]) > 0)largest = right;// 发现原来的data[index]不是最大值if (largest != index) {E temp = data[index];data[index] = data[largest];data[largest] = temp;maxHeapify(data, heapSize, largest);}}/** * 排序，最大值放在末尾，数组data虽然原来是最大堆，排序之后就变成递增的了 */private void heapSort(E[] data) {for (int i = data.length - 1; i > 0; i--) {E temp = data[0];//最大值data[0] = data[i];data[i] = temp;maxHeapify(data, i, 0);}}/** * 父节点位置 */private int getParentIndex(int current) {return (current - 1) >> 1;}/** * 左子节点位置 */private int getChildLeftIndex(int current) {return (current << 1) + 1;}/** * 右子节点位置 */private int getChildRightIndex(int current) {return (current << 1) + 2;}}

过程效果图：