常用排序算法的Java实现与分析
由于需要分析算法的最好时间复杂度和最坏时间复杂度，因此这篇文章中写的排序都是从小到大的升序排序。
带排序的数组为arr，arr的长度为N。时间复杂度使用TC表示，额外空间复杂度使用SC表示。
好多代码都用到了交换arr[i]和arr[j]的地方，这里先给出代码。
private static void swap(int[] arr, int i, int j) { int tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; }
（1）插入排序
1.1直接插入排序
算法思想：
初始时第一个元素是有序的，在插入元素arr[i]时，arr[0] ~arr[i - 1]已经是有序的了，将arr[i]插入其中即可。
稳定性：
如果遇到和arr[i]相等的元素，那么将arr[i]放在后面，所以直接插入排序是稳定的。
复杂度分析：
arr基本有序（升序）时，直接插入排序的TC是O(N)；arr降序时，TC是O(N*N)；平均时间复杂度O(N*N)。直接插入排序的SC是O(1)。
算法实现：
public class InsertionSort_StraightInsertionSort { public static int[] sis(int[] arr) { for (int i = 1; i < arr.length; i++) { for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) { swap(arr, j, j + 1); } } return arr; }
}
1.2希尔排序
算法思想：
希尔排序的实质就是分组插入排序，该方法又称为缩小增量排序。先将arr分割成若干个子序列（由相隔某个增量的元素组成），分别进行直接插入排序，然后依次缩小增量再进行排序。待整个序列中的元素基本有序（增量足够小时），再对全体元素进行一次直接插入排序。
稳定性：
不稳定
复杂度分析：
TC最好为O(N) ，最坏 O(N * N)，平均TC为O(N*1.3)。SC为O(1)。
算法实现：
public class InsertionSort_ShellSort { public static int[] shellSort(int[] arr) { for (int gap = arr.length / 2; gap > 0; gap /= 2) { for (int i = gap; i < arr.length; i++) { for (int j = i - gap; j >= 0 && arr[j] > arr[j + gap]; j -= gap) { swap(arr, j, j + gap); } } } return arr; } }
（2）交换排序
2.1冒泡排序
算法思想：
一次比较两个元素，如果他们的顺序错误就把他们交换过来。
稳定性：
稳定
复杂度分析：
arr升序时TC最好为O(N) ，arr降序时TC最坏 O(N * N)，平均TC为O(N*N)。SC为O(1)
算法实现：
public class Exchange_Bubble { public static int[] bubbleSort(int[] arr) { for (int i = arr.length; i != 0; i--) { for (int j = 1; j < i; j++) { if (arr[j] < arr[j - 1]) { swap(arr, j - 1, j); } } } return arr; } }
2.2快速排序
算法思想：
1．先从数列中取出一个数作为基准数；
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边；
3．再对左右区间重复第二步，直到各区间只有一个数。
稳定性：
不稳定
复杂度分析：
arr升序时TC最好为O(NLogN) ，arr降序时TC最坏 O(N*N)，平均TC为O(NLogN)。SC为O(LogN)
算法实现：
public class Exchange_QuickSort { public static int[] quickSort1(int[] arr) { return qs1(arr, 0, arr.length - 1); } private static int[] qs1(int[] arr, int left, int right) { if (left > right) { return arr; } int i = left; int j = right; int tmp = arr[left]; while (i < j) { while (i < j && arr[j] >= tmp) { j--; } while (i < j && arr[i] <= tmp) { i++; } if (i < j) { swap(arr, i, j); } } arr[left] = arr[i]; arr[i] = tmp; qs1(arr, left, i - 1); qs1(arr, i + 1, right); return arr; } }
(3)选择排序
3.1简单选择排序
算法思想：
在要排序的一组数中，选择出最小的数与第一个数交换；然后在剩下的数中，选择出最小的数与第二个数交换，以此类推。
稳定性：
不稳定
复杂度分析：
arr升序时，只是避免了交换元素的操作，TC最好仍旧为O(N*N) ；arr降序时TC最坏 O(N*N)，平均TC为O(N*N)。SC为O(1)
算法实现：
public class SelectionSort_SimpleSelectionSort { public static int[] simpleSelectionSort(int[] arr) { for (int i = 0; i < arr.length; i++) { int minIdx = i; for (int j = i + 1; j < arr.length; j++) { if (arr[j] < arr[minIdx]) { minIdx = j; } } if (arr[minIdx] < arr[i]) { swap(arr, minIdx, i); } } return arr; } }
3.2堆排序
算法思想：
从小到大排序，构建大顶堆(堆首先是一棵完全二叉树，大顶堆每个节点的值都不大于父节点的值)，然后每次将堆顶元素和没有排序的最后的元素交换，重新构建堆（即重新得到最大的堆顶元素）。
稳定性：
不稳定
复杂度分析：
最好情况：如果待排序数组是降序的，仍然需要O(N * logN)复杂度的比较操作，少了移动的操作；
最坏情况：如果待排序数组是升序的，不仅需要O(N * logN)复杂度的比较操作，而且需要O(N * logN)复杂度的交换操作。总的时间复杂度还是O(N * logN)。
在最好和最坏情况下，堆排序的时间复杂度都是O(NlogN)。堆排序时，由于每次重新恢复堆的时间复杂度为O(logN)，共N - 1次堆调整操作，再加上前面建立堆时N / 2次向下调整，每次调整时间复杂度也为O(logN)。两次次操作时间相加还是O(N * logN)。故堆排序的时间复杂度为O(N * logN)。
堆排序一般优于快速排序的重要一点是，数据的初始分布情况对堆排序的效率没有大的影响。
算法实现：
public class SelectionSort_HeapSort { public static int[] heapSort(int[] arr) { buildHeap(arr); for (int i = arr.length - 1; i >= 0; i--) { swap(arr, 0, i);//交换完后，大的元素跑到了数组的后面的部分 所以堆排序时 数组后面到前面逐渐变得有序 heapify(arr, 0, i); //调整回大顶堆，即重新找到未排序部分的最大值 } return arr; } private static void buildHeap(int[] arr) { for (int i = (arr.length - 1) / 2; i >= 0; i--) { heapify(arr, i, arr.length); } } //从index开始往下不断调整大顶堆 private static void heapify(int[] arr, int index, int heapSize) { int left = index * 2 + 1; int right = index * 2 + 2; int largest = index; while (left < heapSize) { if (arr[left] > arr[index]) { largest = left; } if (right < heapSize && arr[right] > arr[largest]) { largest = right; } if (largest != index) { swap(arr, largest, index); } else { break; } index = largest; left = index * 2 + 1; right = index * 2 + 2; } } }
（4）不基于比较的排序
4.1桶排序
算法思想：
桶排序可用于最大最小值相差较大的数据情况，要求数据的分布必须均匀，否则可能导致数据都集中到一个桶中。把数组 arr 划分为n个大小相同子区间（桶），每个子区间各自排序，最后合并。计数排序是桶排序的一种特殊情况，可以把计数排序当成每个桶里只有一个元素的情况。
1.找出待排序数组中的最大值max、最小值min；
2.我们使用 动态数组ArrayList 作为桶，桶里放的元素也用 ArrayList 存储。桶的数量为(max-min)/arr.length+1；
3.遍历数组 arr，计算每个元素 arr[i] 放的桶；4.每个桶各自排序；5.遍历桶数组，把排序好的元素放进输出数组。
稳定性：
稳定
复杂度分析：
N个待排数据，M个桶，平均每个桶[N/M]个数据的桶排序平均时间复杂度为：O(N)+O(M*(N/M)log(N/M))=O(N+N(logN-logM))=O(N+N*logN-N*logM)
当N=M时，即极限情况下每个桶只有一个数据时。桶排序的最好效率能够达到O(N)。
桶排序的平均时间复杂度为线性的O(N+C)，其中C=N*(logN-logM)。如果相对于同样的N，桶数量M越大，其效率越高，最好的时间复杂度达到O(N)。
桶排序的空间复杂度 为O(N+M)，如果输入数据非常庞大，而桶的数量也非常多，则空间代价无疑是昂贵的。
算法实现：
public class NoCompare_BucketSort { public static int[] bucketSort(int[] arr) { int max = Integer.MIN_VALUE; int min = Integer.MAX_VALUE; for (int cur : arr) { max = Math.max(max, cur); min = Math.min(min, cur); } //计算桶的数量并构建初始的桶 int bucketNum = (max - min) / arr.length + 1; // int bucketNum = (max - min) + 1; //每个桶中只有一个元素的时候就是计数排序 List<List<Integer>> buckets = new ArrayList<>(); for (int i = 0; i < bucketNum; i++) { buckets.add(new ArrayList<>()); } //将每个元素放到桶中 for (int cur : arr) { int index = (cur - min) / arr.length; // int index = (cur - min); //每个桶中只有一个元素的时候就是计数排序 buckets.get(index).add(cur); } //对每个桶内的元素进行排序，可以使用直接插入排序等排序方法 int index = 0; for (List<Integer> bucket : buckets) { insertSort(bucket); for (int cur : bucket) { arr[index++] = cur; } } return arr; } private static void insertSort(List<Integer> bucket) { Integer[] arr = bucket.toArray(new Integer[bucket.size()]); for (int i = 1; i < arr.length; i++) { for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) { swap(arr, j, j + 1); } } for (int i = 0; i < arr.length; i++) { bucket.set(i, arr[i]); } } }
4.2基数排序
算法思想：
基数排序（Radix Sort）是一种非比较型排序算法，它将整数按位数切割成不同的数字，然后按每个位分别进行排序。
基数排序的方式可以采用MSD（Most significant digital）或LSD（Least significant digital），MSD是从最高有效位开始排序，而LSD是从最低有效位开始排序。当然我们可以采用MSD方式排序，按最高有效位进行排序，将最高有效位相同的放到一堆，然后再按下一个有效位对每个堆中的数递归地排序，最后再将结果合并起来。但是，这样会产生很多中间堆（高位排序比低位排序多了空间开销）。所以，通常基数排序采用的是LSD方式。LSD基数排序实现的基本思路是将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
需要注意的是，对每一个数位进行排序的算法必须是稳定的，否则就会取消前一次排序的结果。
稳定性：
稳定
复杂度分析：
设待排序列为n个记录，d个关键码，关键码的取值范围为radix，则进行链式基数排序的时间复杂度为O(d(n+radix))，其中，一趟分配时间复杂度为O(n)，一趟收集时间复杂度为O(radix)，共进行d趟分配和收集。
空间效率：需要2*radix个指向队列的辅助空间，以及用于静态链表的n个指针。
算法实现：
public class NoCompare_RadixSort { public static int[] radixSort(int[] arr) { int maxLen = getMaxBit(arr);//得到arr中最大的数的长度 int[] tmp = new int[arr.length]; int[] count = new int[10];// 计数器 int radix = 1; for (int i = 1; i <= maxLen; i++) {// 进行maxLen次排序 Arrays.fill(count, 0);// 每次分配前清空计数器 for (int j = 0; j < arr.length; j++) { int k = (arr[j] / radix) % 10;// 统计每个桶中的记录数 count[k]++; } for (int j = 1; j < 10; j++) { count[j] = count[j - 1] + count[j];// 将tmp中的位置依次分配给每个桶 } for (int j = arr.length - 1; j != -1; j--) {// 将所有桶中的记录依次收集到tmp中 int k = (arr[j] / radix) % 10; tmp[count[k] - 1] = arr[j]; count[k]--; } for (int j = 0; j < arr.length; j++) {// 将临时数组的内容复制到arr中 arr[j] = tmp[j]; } radix = radix * 10; } return arr; } // 得到arr中最大的数的长度 private static int getMaxBit(int[] arr) { int maxNum = Integer.MIN_VALUE; for (int cur : arr) { maxNum = Math.max(maxNum, cur); } return String.valueOf(maxNum).length(); } }
（5）归并排序
算法思想：
将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行合并。
可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，
可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。
稳定性：
稳定
复杂度分析：
最好、最坏、平均TC都是O(NlogN)。SC是O(N)
算法实现：
public class MergeSort { //将arr[first~mid]和arr[mid~last]合并到tmp中 private static void mergeArray(int[] arr, int first, int mid, int last, int[] tmp) { int begin1 = first; int begin2 = mid + 1; int end1 = mid; int end2 = last; int k = 0; while (begin1 <= end1 && begin2 <= end2) { if (arr[begin1] < arr[begin2]) { tmp[k++] = arr[begin1++]; } else { tmp[k++] = arr[begin2++]; } } while (begin1 <= end1) { tmp[k++] = arr[begin1++]; } while (begin2 <= end2) { tmp[k++] = arr[begin2++]; } //将辅助数组tmp的数据写回arr for (begin1 = 0; begin1 < k; begin1++) { arr[first + begin1] = tmp[begin1]; } } public static int[] mergeSort(int[] arr, int first, int last, int[] tmp) { if (first < last) { int mid = (first + last) / 2; mergeSort(arr, first, mid, tmp);//左边有序 mergeSort(arr, mid + 1, last, tmp);//右边有序 mergeArray(arr, first, mid, last, tmp);//将两个有序数列合并 } return arr; } }
此外，为了验证结果的正确性，可以写个和Arrays.sort()方法比较的代码。getIntArr得到一个大小是size，最大值小于bound的int数组。arrEquals比较两个int数组是否相等。
public class MyUtil { public static int[] getIntArr(int size, int bound) { int[] arr = new int[size]; Random r = new Random(); for (int i = 0; i < size; i++) { arr[i] = r.nextInt(bound); } return arr; } public static boolean arrEquals(int[] arr1, int[] arr2) { for (int i = 0; i < arr1.length; i++) { if (arr1[i] != arr2[i]) { return false; } } return true; } }
以直接插入排序为例，我们可以这么用MyUtil。
public static void main(String[] args) { int times = 0; while (times++ < 100) { int[] arr = MyUtil.getIntArr(50, 100); int[] brr = arr.clone(); Arrays.sort(arr); if (!MyUtil.arrEquals(arr, sis(brr))) { System.out.println("Something Wrong"); } } System.out.println("Everything is OK."); }
