在阅读本文之前，建议读者优先阅读专栏内前面的文章。
目录
前言
本文主要讲解如何用Java实现常见的几种排序方式。
一、排序的概念及引用：
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。
排序又分为内部排序和外部排序，内部排序为数据元素全部放在内存中的排序；外部排序则为数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。排序的应用很常见，比如下面的场景：
常见的排序算法，同时也是我们即将讲到的，又分为下面这些：
二、插入排序：
直接插入排序是一种简单的插入排序法，其基本思想是把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。实际中我们玩扑克牌时，就用了插入排序的思想。
我们首先先来看一下直接插入排序。当插入第i(i>=1)个元素时，前面的array0,array1,...,arrayi-1已经排好序，此时用arrayi的排序码与arrayi-1,arrayi-2,...的排序码顺序进行比较，找到插入位置即将arrayi插入，原来位置上的元素顺序后移。
这种排序的思路相对来说比较简单，读者可先自行思考，我这里给出我的代码：
java
public class Sort {
public static void insertSort(int[] array){
for(int i = 1; i < array.length; i++){
int temp = array[i];
int j = i - 1;
for(; j >= 0; j--){
if(array[j] > temp){
array[j + 1] = array[j];
}else{
array[j + 1] = temp;
break;
}
}
array[j + 1] = temp;
}
}
}
java
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] array = {9, 2, 8, 3, 7, 1, 5, 0, 4, 6};
System.out.println(Arrays.toString(array));
Sort.insertSort(array);
System.out.println(Arrays.toString(array));
}
}其运行结果如下：
对于直接插入排序来说，它的时间复杂度是O(n^2)，因为相当于是有1+2+......+n-1次执行。对于直接插入排序来说，原始数组越有序，直接插入排序越快。由于仅仅创建额外的一个变量，所以它的空间复杂度是O(1)。并且直接插入排序是一种稳定的算法。我们接下来可以分别写一个生成有序和无序数组的方法，进而更直观的看出初始数据有序性对于运行时间的影响。我们首先先来生成这两个目标数组：
java
public static void orderArray(int[] array) {
for(int i = 0; i < array.length; i++){
array[i] = i;
}
}
public static void notOrderArray(int[] array) {
Random random = new Random();
for(int i = 0; i < array.length; i++){
array[i] = random.nextInt(100000);
}
}接下来我们可以来计算二者排序具体的时间。首先我们先把刚刚写好的main方法给变成一个普通的方法，方便后续多次调用；再写一个专门测验有序无序数组的方法。我的代码如下：
java
public static void testSimple() {
int[] array = {9, 2, 8, 3, 7, 1, 5, 0, 4, 6};
System.out.println(Arrays.toString(array));
Sort.insertSort(array);
System.out.println(Arrays.toString(array));
}
public static void testOther(){
int[] array = new int[100000];
orderArray(array);
testInsert(array);
notOrderArray(array);
testInsert(array);
}然后我们可以来实现上面未实现的testInsert方法，它主要可以用来统计算法实际运转的时间，单位是毫秒。其代码如下：
java
public static void testInsert(int[] array) {
array = Arrays.copyOf(array, array.length);
long startTime = System.currentTimeMillis();
Sort.insertSort(array);
long endTime = System.currentTimeMillis();
System.out.println("直接插入排序耗时：" + (endTime - startTime) + "ms");
}其运行结果如下，我们可以发现有序比无序确实快了很多很多。
接下来我们来看下希尔排序，希尔排序法又称缩小增量法。希尔排序法的基本思想是先选定一个整数，把待排序文件中所有记录分成多个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
总的来说，希尔排序是对直接插入排序的优化。当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排序的时间复杂度都不固定。严蔚敏老师是这样说的：
殷人昆老师是这么说的：
因为咱们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照O(n^1.25)到O(1.6 * n^1.25)来算。它的空间复杂的还是O(1)。除此之外，希尔排序是一种不稳定的排序方法。我们的代码如下：
java
public static void shellSort(int[] array){
int gap = array.length;
while(gap > 1){
gap /= 2;
shell(array, gap);
}
}
private static void shell(int[] array, int gap) {
for(int i = gap; i < array.length; i++){
int temp = array[i];
int j = i - gap;
for(; j >= 0; j -= gap){
if(array[j] > temp){
array[j + gap] = array[j];
}else{
array[j + gap] = temp;
break;
}
}
array[j + gap] = temp;
}
}测试代码如下：
java
import java.util.Arrays;
import java.util.Random;
public class Main {
public static void orderArray(int[] array) {
for(int i = 0; i < array.length; i++){
array[i] = i;
}
}
public static void notOrderArray(int[] array) {
Random random = new Random();
for(int i = 0; i < array.length; i++){
array[i] = random.nextInt(100000);
}
}
/**
* 测试简单的数据能否执行，测试算法是否正确
*/
public static void testSimple() {
int[] array = {9, 2, 8, 3, 7, 1, 5, 0, 4, 6};
System.out.println(Arrays.toString(array));
Sort.shellSort(array);
System.out.println(Arrays.toString(array));
}
public static void testOther(){
int[] array = new int[100000];
orderArray(array);
testShell(array);
notOrderArray(array);
testShell(array);
}
public static void testShell(int[] array) {
array = Arrays.copyOf(array, array.length);
long startTime = System.currentTimeMillis();
Sort.shellSort(array);
long endTime = System.currentTimeMillis();
System.out.println("希尔插入排序耗时：" + (endTime - startTime) + "ms");
}
public static void main(String[] args) {
testSimple();
testOther();
}
}其运行结果如下：
所以可以看到如果数组无序，我们的希尔排序耗时大幅减少。所以希尔排序比直接插入排序更为高效。
三、选择排序：
选择排序的基本思想就是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。其中比较简单的就是简单选择排序，他的思想就是在元素集合arrayi--arrayn-1中选择关键码最大(小)的数据元素。若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个(第一个)元素交换，在剩余的arrayi--arrayn-2（arrayi+1--arrayn-1）集合中，重复上述步骤，直到集合剩余1个元素。
可以看到，其实这个排序也是很容易去实现的，读者可以先自行试验一下，我这里给出我的代码：
java
public static void selectSort(int[] array){
for(int i = 0; i < array.length; i++){
int minIndex = i;
for(int j = i + 1; j < array.length; j++){
if(array[j] < array[minIndex]){
minIndex = j;
}
}
swap(array, i, minIndex);
}
}
private static void swap(int[] array, int index1, int index2){
int temp = array[index1];
array[index1] = array[index2];
array[index2] = temp;
}
java
import java.util.Arrays;
import java.util.Random;
public class Main {
public static void orderArray(int[] array) {
for(int i = 0; i < array.length; i++){
array[i] = i;
}
}
public static void notOrderArray(int[] array) {
Random random = new Random();
for(int i = 0; i < array.length; i++){
array[i] = random.nextInt(100000);
}
}
/**
* 测试简单的数据能否执行，测试算法是否正确
*/
public static void testSimple() {
int[] array = {9, 2, 8, 3, 7, 1, 5, 0, 4, 6};
System.out.println(Arrays.toString(array));
Sort.selectSort(array);
System.out.println(Arrays.toString(array));
}
public static void testOther(){
int[] array = new int[100000];
orderArray(array);
testSelect(array);
notOrderArray(array);
testSelect(array);
}
public static void testSelect(int[] array) {
array = Arrays.copyOf(array, array.length);
long startTime = System.currentTimeMillis();
Sort.selectSort(array);
long endTime = System.currentTimeMillis();
System.out.println("直接选择排序耗时：" + (endTime - startTime) + "ms");
}
public static void main(String[] args) {
testSimple();
testOther();
}
}我们得到结果如下：
直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用。不管是否有序，它的时间复杂度都是O(N^2)，空间复杂度为O(1)，并且是种不稳定的算法。当然我们也可以优化一下这个算法，也就是同时得到最小值和最大值，然后一次换两个：
java
public static void selectSort(int[] array){
int left = 0;
int right = array.length - 1;
while(left < right){
int minIndex = left;
int maxIndex = left;
for(int i = left + 1; i <= right; i++){
if(array[i] < array[minIndex]){
minIndex = i;
}
if(array[i] > array[maxIndex]){
maxIndex = i;
}
}
swap(array, left, minIndex);
if(maxIndex == left){
maxIndex = minIndex;
}
swap(array, right, maxIndex);
left++;
right--;
}
}
private static void swap(int[] array, int index1, int index2){
int temp = array[index1];
array[index1] = array[index2];
array[index2] = temp;
}我们运行后结果如下：
可以看到，其实就算优化后，它的时间复杂度还是同样的，并没有变化。下一种排序方法就是我们之前提过的堆排序，这里不多做赘述，直接给出我的代码：
java
private static void swap(int[] array, int index1, int index2){
int temp = array[index1];
array[index1] = array[index2];
array[index2] = temp;
}
public static void heapSort(int[] array) {
createHeap(array);
int end = array.length - 1;
while(end > 0){
swap(array, 0, end);
siftDown(array, 0, end);
end--;
}
}
private static void createHeap(int[] array){
for(int parent = array.length / 2 - 1; parent >= 0; parent--){
siftDown(array, parent, array.length);
}
}
/**
*
* @param array
* @param parent 每棵子树调整时候的根节点
* @param length 每棵子树调整时候的结束节点
*/
private static void siftDown(int[] array, int parent, int length){
int child = parent * 2 + 1;
while(child < length){
if(child + 1 < length && array[child] < array[child + 1]){
child++;
}
if(array[child] > array[parent]){
swap(array, child, parent);
parent = child;
child = parent * 2 + 1;
}else{
break;
}
}
}
java
import java.util.Arrays;
import java.util.Random;
public class Main {
public static void orderArray(int[] array) {
for(int i = 0; i < array.length; i++){
array[i] = i;
}
}
public static void notOrderArray(int[] array) {
Random random = new Random();
for(int i = 0; i < array.length; i++){
array[i] = random.nextInt(100000);
}
}
/**
* 测试简单的数据能否执行，测试算法是否正确
*/
public static void testSimple() {
int[] array = {9, 2, 8, 3, 7, 1, 5, 0, 4, 6};
System.out.println(Arrays.toString(array));
Sort.heapSort(array);
System.out.println(Arrays.toString(array));
}
public static void testOther(){
int[] array = new int[100000];
orderArray(array);
testHeap(array);
notOrderArray(array);
testHeap(array);
}
public static void testHeap(int[] array) {
array = Arrays.copyOf(array, array.length);
long startTime = System.currentTimeMillis();
Sort.heapSort(array);
long endTime = System.currentTimeMillis();
System.out.println("堆排序耗时：" + (endTime - startTime) + "ms");
}
public static void main(String[] args) {
testSimple();
testOther();
}
}其运行结果如下：
对于堆排序相关分析的话，它的效率就高了很多。它的时间复杂度为O(N*logN)，空间复杂度为O(1)，是一种相对不稳定的算法。
四、交换排序：
所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。在交换排序中最简单的一种就是之前我们讲过多次的冒泡排序，这里不再赘述，直接给出我的代码：
java
public static void bubbleSort(int[] array){
for(int i = 0; i < array.length; i++){
boolean flag = false;
for(int j = 0; j < array.length - i - 1; j++){
if(array[j] > array[j + 1]){
swap(array, j, j + 1);
flag = true;
}
}
if(!flag){
break;
}
}
}需要注意，我们在分析它的时间复杂度的时候是不考虑它标志位的代码的，这样的话它的时间复杂度就是O(N^2)，空间复杂度为O(1)，并且是一种稳定的排序算法。当我们优化代码之后，它的时间复杂度就可能达到O(N)的程度。由于对于这种算法比较熟悉，这里就不去测试具体效率了。我们来看下下面这种相对最重要的算法，快速排序。
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
java
// 假设按照升序对array数组中[left, right)区间中的元素进行排序
void QuickSort(int[] array, int left, int right){
if(right - left <= 1)
return;
// 按照基准值对array数组的 [left, right)区间中的元素进行划分
int div = partion(array, left, right);
// 划分成功后以div为边界形成了左右两部分 [left, div) 和 [div+1, right)
// 递归排[left, div)
QuickSort(array, left, div);
// 递归排[div+1, right)
QuickSort(array, div+1, right);
}上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，读者在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。这其中将区间按照基准值划分为左右两半部分的常见方式有多种，我们一一来介绍，首先是Hoare版：
java
private static void swap(int[] array, int index1, int index2){
int temp = array[index1];
array[index1] = array[index2];
array[index2] = temp;
}
public static void quickSort(int[] array){
quick(array, 0, array.length - 1);
}
private static void quick(int[] array, int start, int end){
if(start >= end){
return;
}
int pivot = partition(array, start, end);
quick(array, start, pivot - 1);
quick(array, pivot + 1, end);
}
private static int partition(int[] array, int left, int right){
int tmp = array[left];
int tmpLeft = left;
while(left < right){
while(left < right && array[right] >= tmp){
right--;
}
while(left < right && array[left] <= tmp){
left++;
}
swap(array, left, right);
}
swap(array, left, tmpLeft);
return left;
}我们代码的核心思想每一轮选择一个基准值pivot，然后通过一次分区操作，把比基准值小的元素放到它的左边，把比基准值大的元素放到它的右边。这样基准值就被放到了最终应该出现的位置。之后再分别对基准值左边和右边的子数组继续进行同样的操作，直到每个区间只剩下一个元素或没有元素为止。quickSort方法是快速排序的入口：
java
public static void quickSort(int[] array){
quick(array, 0, array.length - 1);
}它直接调用quick方法，对整个数组0, array.length - 1这个范围进行排序。quick方法负责递归排序，我们写这个方法是为了保证上面的方法传入参数能够与其他排序的方法传参种类和数量相同。
java
private static void quick(int[] array, int start, int end){
if(start >= end){
return;
}
int pivot = partition(array, start, end);
quick(array, start, pivot - 1);
quick(array, pivot + 1, end);
}其中start和end表示当前需要排序的区间范围。如果start >= end，说明这个区间中最多只有一个元素，不需要继续排序，直接返回。否则就调用partition方法进行分区。分区完成后，partition会返回基准值最终所在的位置pivot。由于基准值已经被放到了正确的位置，所以接下来只需要递归处理它左边的区间start, pivot - 1和右边的区间pivot + 1, end。然后就是整段代码最关键的部分partition方法：
java
private static int partition(int[] array, int left, int right){
int tmp = array[left];
int tmpLeft = left;
while(left < right){
while(left < right && array[right] >= tmp){
right--;
}
while(left < right && array[left] <= tmp){
left++;
}
swap(array, left, right);
}
swap(array, left, tmpLeft);
return left;
}这里选择当前区间最左边的元素arrayleft作为基准值，并用tmp保存下来。tmpLeft记录的是基准值一开始所在的位置，因为后面left指针会不断移动，必须单独保存原始位置，方便最后把基准值交换到正确位置。分区过程使用了两个指针，left从左往右走，right从右往左走。由于基准值取的是最左边的元素，所以代码先让right指针向左移动，寻找第一个比基准值小的元素：
java
while(left < right && array[right] >= tmp){
right--;
}当arrayright < tmp时，说明右边找到了一个应该放到左边去的元素。然后让left指针向右移动，寻找第一个比基准值大的元素：
java
while(left < right && array[left] <= tmp){
left++;
}当arrayleft > tmp时，说明左边找到了一个应该放到右边去的元素。此时，arrayleft是一个偏大的元素，arrayright是一个偏小的元素，二者位置不合适，所以调用swap(array, left, right)将它们交换。这样一来，小的元素被放到了左边，大的元素被放到了右边。这个过程会一直重复，直到left和right相遇。相遇的位置就是基准值最终应该放置的位置。最后执行：
java
swap(array, left, tmpLeft);把最开始放在左端的基准值交换到相遇位置。此时，基准值左边的元素都小于或等于它，右边的元素都大于或等于它，所以基准值的位置已经确定，partition方法返回这个位置。
快速排序的平均时间复杂度是O(nlogn)，因为每次分区都能把数组大致分成两半。但是在最坏情况下，比如数组本身已经有序，或者大量元素重复，而代码又总是选择最左边元素作为基准值时，快速排序可能退化成O(n²)。这是因为每次分区都只能确定一个元素的位置，递归深度会接近n。而在空间复杂度方面，快速排序主要消耗的是递归调用栈。平均情况下递归深度为O(logn)，所以空间复杂度为O(logn)；最坏情况下递归深度可能达到O(n)。我们如果运行如下代码：
java
import java.util.Arrays;
import java.util.Random;
public class Main {
public static void orderArray(int[] array) {
for(int i = 0; i < array.length; i++){
array[i] = i;
}
}
public static void notOrderArray(int[] array) {
Random random = new Random();
for(int i = 0; i < array.length; i++){
array[i] = random.nextInt(100000);
}
}
/**
* 测试简单的数据能否执行，测试算法是否正确
*/
public static void testSimple() {
int[] array = {9, 2, 8, 3, 7, 1, 5, 0, 4, 6};
System.out.println(Arrays.toString(array));
Sort.quickSort(array);
System.out.println(Arrays.toString(array));
}
public static void testOther() {
int[] array = new int[100000];
orderArray(array);
testQuick(array);
notOrderArray(array);
testQuick(array);
}
public static void testQuick(int[] array) {
array = Arrays.copyOf(array, array.length);
long startTime = System.currentTimeMillis();
Sort.quickSort(array);
long endTime = System.currentTimeMillis();
System.out.println("快速排序耗时：" + (endTime - startTime) + "ms");
}
public static void main(String[] args) {
testSimple();
testOther();
}
}其运行结果如下：
因为空间太多导致栈溢出。需要注意的是，我目前写的这段快速排序是原地排序，它不需要额外创建数组，主要通过交换数组内部元素完成排序。但是它不是稳定排序，因为在交换过程中，相同元素的相对顺序可能发生变化。我们接下来介绍另一种挖坑法：
java
private static int partitionHole(int[] array, int left, int right){
int tmp = array[left];
while(left < right){
while(left < right && array[right] >= tmp){
right--;
}
array[left] = array[right];
while(left < right && array[left] <= tmp){
left++;
}
array[right] = array[left];
}
array[left] = tmp;
return left;
}这种代码其实只是替换了partition的方法。我们选择当前区间最左边的元素作为基准值tmp，然后通过左右指针不断移动，使得比基准值小的元素移动到左边，比基准值大的元素移动到右边。最终返回基准值所在的位置。一开始代码把最左边的元素保存到tmp中。此时可以理解为left位置上的元素已经被拿走了，所以left位置形成了一个坑。接下来从右边开始找，让right指针从右向左移动，寻找第一个小于基准值tmp的元素。因为小于基准值的元素应该放到左边，所以找到之后，就把它填到左边的坑里，此时左边的坑被填上了，但是right位置上的元素被移动走了，所以right位置又形成了一个新的坑。然后从左边开始找，这一步让left指针从左向右移动，寻找第一个大于基准值tmp的元素。因为大于基准值的元素应该放到右边，所以找到之后，就把它填到右边的坑里，此时右边的坑被填上了，但是left位置上的元素又被移动走了，所以新的坑又回到了左边。整个过程就是不断重复右边找小的，填到左边坑里；左边找大的，填到右边坑里。直到left和right相遇，说明左右两边已经完成分区。此时相遇的位置就是最后剩下的坑，也就是基准值最终应该放置的位置，最后把一开始保存的基准值 tmp 放回这个坑中，并返回该位置。
挖坑法和普通交换法的区别在于交换法是每次找到左右两边不合适的元素后直接交换，而挖坑法是先把基准值保存起来，然后通过"填坑"的方式移动元素，最后再把基准值放回最终位置。它本质上仍然是在完成快速排序中的分区操作。这段代码的单次分区时间复杂度是O(n)，因为左右指针最多只会从区间两端向中间扫描一遍。配合快速排序整体使用时，平均时间复杂度是O(nlogn)，最坏情况下可能退化为O(n²)。尤其是当数组本身接近有序，而代码总是选择最左边元素作为基准值时，更容易出现退化。需要注意的是，这种快速排序也不是稳定排序。因为元素在分区过程中会被移动，相同元素之间原本的相对顺序可能被改变。然后第三种则是前后指针法：
java
private static int partition2Ptr1(int[] array, int left, int right) {
int prev = left ;
int cur = left+1;
while (cur <= right) {
if(array[cur] < array[left] && array[++prev] != array[cur]) {
swap(array,cur,prev);
}
cur++;
}
swap(array,prev,left);
return prev;
}这种方法的思路就是选择当前区间最左边的元素arrayleft作为基准值，然后通过prev和cur两个指针，把小于基准值的元素集中放到左边，把大于或等于基准值的元素留在右边。最后再把基准值交换到中间位置。我们首先做出定义：
java
int prev = left;
int cur = left + 1;prev表示小于基准值区域的最后一个位置，cur表示当前正在遍历的位置。由于arrayleft被选为基准值，所以cur从left + 1开始扫描。在循环过程中，可以把数组分成三个区域：
java
[left] //基准值
[left + 1, prev] //小于基准值的区域
[prev + 1, cur - 1] //大于或等于基准值的区域
[cur, right] //还没有处理的区域在循环中，cur会从左到右依次扫描整个区间。当发现当前元素小于基准值时：
java
if(array[cur] < array[left] && array[++prev] != array[cur]) {
swap(array,cur,prev);
}说明arraycur应该被放到左边的小于基准值区域中。因此代码先执行++prev，把小于基准值区域向右扩大一格，然后把cur位置的元素交换到prev位置。也就是说，只要遇到一个小于基准值的元素，就把它放到小于区域的末尾。如果当前元素大于或等于基准值，那么不需要处理，直接让cur++继续扫描即可。因为这类元素本来就应该留在基准值的右边区域。当循环结束后，所有小于基准值的元素都已经被移动到了left + 1, prev这个范围内，而prev + 1, right范围内的元素都大于或等于基准值。最后执行：
java
swap(array,prev,left);
return prev;把最左边的基准值交换到prev位置。这样一来，基准值左边的元素都小于它，右边的元素都大于或等于它，基准值就被放到了最终应该出现的位置。
前后指针法的特点是只使用一个指针cur从左到右扫描数组，再用prev记录小于基准值区域的边界。相比左右指针法，它的移动方向更单一，逻辑也比较清晰。这段代码的单次分区时间复杂度是O(n)，因为cur只会从左到右扫描一遍数组。快速排序整体平均时间复杂度是O(nlogn)，最坏情况下仍然可能退化为O(n²)。如果数组本身接近有序，而每次都选择最左边元素作为基准值，就容易出现这种退化情况。需要注意的是，这种快速排序仍然不是稳定排序。因为在分区过程中会发生元素交换，相同元素的相对顺序可能被改变。当然我们也可以向下面这样实现：
java
private static int partition2Ptr2(int[] array, int left, int right) {
int d = left + 1;
int pivot = array[left];
for (int i = left + 1; i <= right; i++) {
if (array[i] < pivot) {
swap(array, i, d);
d++;
}
}
swap(array, d - 1, left);
return d - 1;
}这里需要明确注意，我们最常用的一种就是挖坑法，如果没有提及，大部分指代的都是挖坑法。虽然快速排序的效率比前面的排序算法显著提高了，但是对于我们来说还是不太够，那我们该如何对快速排序进行优化呢？
五、快速排序的优化：
快排的第一种优化方法叫做三数取中法，我们先把具体方法写出来：
java
private static void swap(int[] array, int index1, int index2){
int temp = array[index1];
array[index1] = array[index2];
array[index2] = temp;
}
public static void quickSort(int[] array){
quick(array, 0, array.length - 1);
}
private static void quick(int[] array, int start, int end){
if(start >= end){
return;
}
int midIndex = getMiddleNum(array, start, end);
swap(array, start, midIndex);
int pivot = partitionHole(array, start, end);
quick(array, start, pivot - 1);
quick(array, pivot + 1, end);
}
private static int partitionHole(int[] array, int left, int right){
int tmp = array[left];
while(left < right){
while(left < right && array[right] >= tmp){
right--;
}
array[left] = array[right];
while(left < right && array[left] <= tmp){
left++;
}
array[right] = array[left];
}
array[left] = tmp;
return left;
}
private static int getMiddleNum(int[] array, int left, int right) {
int mid = (left + right) / 2;
if (array[left] < array[mid]) {
if (array[mid] < array[right]) {
return mid;
} else if (array[left] > array[right]) {
return left;
} else {
return right;
}
} else {
if (array[mid] > array[right]) {
return mid;
} else if (array[left] < array[right]) {
return left;
} else {
return right;
}
}
}它不是简单地固定选择区间最左端或最右端元素作为基准值，而是从当前区间的左端、中间和右端三个位置取出元素，并选择其中大小居中的那个元素作为基准值。这样做可以降低在有序、逆序或接近有序数组中选到极端值的概率，使划分结果更加均衡，从而减少快速排序退化为O(n^2)的可能性。三数取中法并不会改变快速排序的基本思想，它只是优化了pivot的选择策略，使快速排序在实际使用中更加稳定。我们改完后运行结果如下：
所以可以看到，它的效率有了明显的提升。当然因为前面方法本身栈的大小限制，我们没办法去直观比较大小。这里我们可以去调整一下IDEA本身的程序的栈的大小。我们可以在如下界面进行调整：
在输入-Xss5m参数后点击确定即可调整栈大小了。接下来第二种优化方法是根据现实分析得到的。由于我们的快速排序是递归的，所以在区间越来越小的过程之中，整个数组是越来越趋近于有序的，而从上面的结论和数据我们知道当序列越有序，其实快速排序效率越低。所以这时我们就可以使用相对来说效率高一些的插入排序来进行替换就可以提高效率了。我的代码如下：
java
public static void quickSort(int[] array){
quick(array, 0, array.length - 1);
}
private static void quick(int[] array, int start, int end){
if(start >= end){
return;
}
if(end - start + 1 <= 10){
insertSortRange(array, start, end);
return;
}
int midIndex = getMiddleNum(array, start, end);
swap(array, start, midIndex);
int pivot = partitionHole(array, start, end);
quick(array, start, pivot - 1);
quick(array, pivot + 1, end);
}
private static void insertSortRange(int[] array, int start, int end){
for(int i = start + 1; i <= end; i++){
int temp = array[i];
int j = i - 1;
for(; j >= start; j--){
if(array[j] > temp){
array[j + 1] = array[j];
}else{
array[j + 1] = temp;
break;
}
}
array[j + 1] = temp;
}
}
private static int partitionHole(int[] array, int left, int right){
int tmp = array[left];
while(left < right){
while(left < right && array[right] >= tmp){
right--;
}
array[left] = array[right];
while(left < right && array[left] <= tmp){
left++;
}
array[right] = array[left];
}
array[left] = tmp;
return left;
}
private static int getMiddleNum(int[] array, int left, int right) {
int mid = (left + right) / 2;
if (array[left] < array[mid]) {
if (array[mid] < array[right]) {
return mid;
} else if (array[left] > array[right]) {
return left;
} else {
return right;
}
} else {
if (array[mid] > array[right]) {
return mid;
} else if (array[left] < array[right]) {
return left;
} else {
return right;
}
}
}
}运行后结果如下：
可以看到效率略有提升。最后一种其实就是用非递归的方式来去替换递归进而得到效率优化。代码大致如下：
java
public static void quickSort(int[] array){
quickNor(array, 0, array.length - 1);
}
public static void quickNor(int[] array, int start, int end){
Deque<Integer> stack = new ArrayDeque<>();
int pivot = partitionHole(array, start, end);
if(pivot > start + 1){
stack.push(start);
stack.push(pivot - 1);
}
if(pivot < end - 1){
stack.push(pivot + 1);
stack.push(end);
}
while(!stack.isEmpty()){
end = stack.pop();
start = stack.pop();
pivot = partitionHole(array, start, end);
if(pivot > start + 1){
stack.push(start);
stack.push(pivot - 1);
}
if(pivot < end - 1){
stack.push(pivot + 1);
stack.push(end);
}
}
}
private static int partitionHole(int[] array, int left, int right){
int tmp = array[left];
while(left < right){
while(left < right && array[right] >= tmp){
right--;
}
array[left] = array[right];
while(left < right && array[left] <= tmp){
left++;
}
array[right] = array[left];
}
array[left] = tmp;
return left;
}
private static void swap(int[] array, int index1, int index2){
int temp = array[index1];
array[index1] = array[index2];
array[index2] = temp;
}非递归快速排序的本质并没有改变快速排序的思想，它只是把递归调用改成了手动使用栈保存待处理区间。也就是说，递归版本中由系统帮我们保存的区间信息，在非递归版本中改为由程序员自己使用一个栈来保存。在这段代码中，使用的是：
java
Deque<Integer> stack = new ArrayDeque<>();这个栈中保存的是待排序区间的左右边界。因为一个区间可以用两个下标表示，例如start, end，所以每次入栈时都需要连续压入两个整数，先压入左边界，再压入右边界。
java
stack.push(start);
stack.push(pivot - 1);表示把基准值左边的子区间start, pivot - 1保存起来，后续继续处理。
java
stack.push(pivot + 1);
stack.push(end);表示把基准值右边的子区间pivot + 1, end保存起来。由于栈具有后进先出的特点，所以取出区间时，需要按照相反的顺序弹出：
javascript
end = stack.pop();
start = stack.pop();这样才能正确得到一个完整的待排序区间。整个非递归快速排序的执行过程可以分为三步。第一步，先对原始区间进行一次分区：
java
int pivot = partitionHole(array, start, end);partitionHole方法会对当前区间进行挖坑法分区，并返回基准值最终所在的位置。分区结束后，基准值左边的元素都小于等于它，右边的元素都大于等于它，因此基准值本身不需要再参与后续排序。第二步，判断基准值左右两边的子区间是否还需要继续排序。如果左区间至少有两个元素，就把左区间入栈：
java
if(pivot > start + 1){
stack.push(start);
stack.push(pivot - 1);
}这里判断pivot > start + 1的原因是，左区间的范围是start, pivot - 1。只有当这个区间中至少有两个元素时，才有继续排序的必要。如果区间为空或者只有一个元素，本身就已经有序，不需要再入栈。右区间的判断也是同理：
java
if(pivot < end - 1){
stack.push(pivot + 1);
stack.push(end);
}右区间的范围是pivot + 1, end。只有当右区间中至少有两个元素时，才需要继续处理。第三步，使用循环不断处理栈中的区间：
java
while(!stack.isEmpty()){
end = stack.pop();
start = stack.pop();
pivot = partitionHole(array, start, end);
if(pivot > start + 1){
stack.push(start);
stack.push(pivot - 1);
}
if(pivot < end - 1){
stack.push(pivot + 1);
stack.push(end);
}
}只要栈不为空，就说明还有子区间没有处理完。每次循环时，从栈中取出一个区间，对这个区间执行一次分区操作，然后继续判断分区后产生的新左区间和新右区间是否需要入栈。这个过程不断重复，直到栈为空为止。当栈为空时，说明所有需要排序的子区间都已经处理完毕，整个数组也就完成了排序。非递归快速排序和递归快速排序在思想上是完全一致的，都是不断对数组区间进行分区，使基准值逐步归位。它们的区别只在于：递归版本依赖系统调用栈保存尚未处理的子区间，而非递归版本使用程序员自己创建的栈来保存这些区间。因此，非递归快速排序可以理解为用手动栈模拟递归过程。这种写法虽然代码比递归版本稍微复杂一些，但是能够避免递归层数过深导致的栈溢出问题，在理解快速排序底层执行过程时也更加直观。其运行结果如下：
总的来说，快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序。它的时间复杂度通常是O(N*logN)，空间复杂度则是O(logN)，是一种不稳定的算法。
六、归并排序：
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤如下图所示：
这个图就很容易理解，我们可以直接写出代码：
java
public static void mergeSort(int[] array) {
mergeSortTmp(array, 0, array.length - 1);
}
private static void mergeSortTmp(int[] array, int left, int right) {
if (left >= right) {
return;
}
int mid = (left + right) / 2;
mergeSortTmp(array, left, mid);
mergeSortTmp(array, mid + 1, right);
merge(array, left, mid, right);
}
private static void merge(int[] array, int left, int mid, int right) {
int[] tmp = new int[right - left + 1];
int k = 0;
int s1 = left;
int e1 = mid;
int e2 = right;
int s2 = mid + 1;
while(s1 <= e1 && s2 <= e2) {
if(array[s1] <= array[s2]) {
tmp[k++] = array[s1++];
}else{
tmp[k++] = array[s2++];
}
}
while(s1 <= e1) {
tmp[k++] = array[s1++];
}
while(s2 <= e2) {
tmp[k++] = array[s2++];
}
for(int i = 0; i < k; i++){
array[left + i] = tmp[i];
}
}
java
import java.util.Arrays;
import java.util.Random;
public class Main {
public static void orderArray(int[] array) {
for(int i = 0; i < array.length; i++){
array[i] = i;
}
}
public static void notOrderArray(int[] array) {
Random random = new Random();
for(int i = 0; i < array.length; i++){
array[i] = random.nextInt(100000);
}
}
/**
* 测试简单的数据能否执行，测试算法是否正确
*/
public static void testSimple() {
int[] array = {9, 2, 8, 3, 7, 1, 5, 0, 4, 6};
System.out.println(Arrays.toString(array));
//Sort.insertSort(array);
//Sort.shellSort(array);
//Sort.selectSort(array);
//Sort.heapSort(array);
//Sort.quickSort(array);
Sort.mergeSort(array);
System.out.println(Arrays.toString(array));
}
public static void testOther() {
int[] array = new int[100000];
orderArray(array);
testMerge(array);
notOrderArray(array);
testMerge(array);
}
public static void testMerge(int[] array) {
array = Arrays.copyOf(array, array.length);
long startTime = System.currentTimeMillis();
Sort.mergeSort(array);
long endTime = System.currentTimeMillis();
System.out.println("归并插入排序耗时：" + (endTime - startTime) + "ms");
}
public static void main(String[] args) {
testSimple();
testOther();
}
}其运行结果如下：
所以归并需要O(N)的空间复杂度，时间复杂度则为O(N*logN)，是一种稳定的算法。归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。我们上面讲解的全部的算法都是内部排序。那么对于外部排序我们又该如何操作？首先外部排序指的是排序过程需要在磁盘等外部存储进行的排序。它的前提是内存只有1G，需要排序的数据有100G。因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序，我们做法如下。先把文件切分成200份，每个512M；分别对512M排序，因为内存已经可以放的下，所以任意排序方式都可以；进行2路归并，同时对200份有序文件做归并过程，最终结果就有序了。很明显我们上面是用递归来实现归并排序，那么我们该如何用非递归来实现它呢？我的代码如下：
java
private static void merge(int[] array, int left, int mid, int right) {
int[] tmp = new int[right - left + 1];
int k = 0;
int s1 = left;
int e1 = mid;
int e2 = right;
int s2 = mid + 1;
while(s1 <= e1 && s2 <= e2) {
if(array[s1] <= array[s2]) {
tmp[k++] = array[s1++];
}else{
tmp[k++] = array[s2++];
}
}
while(s1 <= e1) {
tmp[k++] = array[s1++];
}
while(s2 <= e2) {
tmp[k++] = array[s2++];
}
for(int i = 0; i < k; i++){
array[left + i] = tmp[i];
}
}
public static void mergeSortNor(int[] array) {
int gap = 1;
while(gap < array.length){
for(int i = 0; i < array.length; i = i + gap * 2){
int left = i;
int mid = left + gap - 1;
if(mid > array.length){
mid = array.length - 1;
}
int right = mid + gap;
if(right >= array.length){
right = array.length - 1;
}
merge(array, left, mid, right);
}
gap *= 2;
}
}递归版归并排序通常是先递归地把数组拆成左右两部分，然后再合并。而非递归归并排序的思路正好反过来：它不通过递归拆分数组，而是从最小的区间开始，先把长度为1的小区间两两合并成长度为2的有序区间，再把长度为2的区间两两合并成长度为4的有序区间，接着合并成长度为8、16......直到整个数组有序。也就是说，非递归归并排序是一个从小到大逐层合并的过程。我们来看下来看非递归归并排序的主体代码。我们一开始先把每一个元素都看成一个长度为1的有序区间。因为单个元素天然就是有序的。然后执行继续把相邻的两个长度为2的有序区间合并，得到长度为4的有序区间。再把两个长度为4的有序区间合并，最终得到完整的有序数组所以，非递归归并排序的核心就是不断扩大gap的值，每一轮都把相邻的两个有序区间合并成一个更大的有序区间。内层for循环用于控制每一轮中具体合并哪些区间：
java
for(int i = 0; i < array.length; i = i + gap * 2)因为每次合并的是两个长度为gap的区间，所以一次合并最多会处理gap * 2个元素。因此，每次循环结束后，i要向后移动gap * 2个位置。在每一次循环中：
java
int left = i;
int mid = left + gap - 1;
int right = mid + gap;这三行代码用于确定当前要合并的区间范围。其中left表示当前合并区间的起始位置。mid表示左半部分区间的结束位置。right表示右半部分区间的结束位置。所以当前要合并的两个区间分别是left, mid和mid + 1, right，最后调用下面的代码完成这两个有序区间的合并。
java
merge(array, left, mid, right);七、各种排序复杂度与稳定分析：
| 排序方法 | 最好 | 平均 | 最坏 | 空间复杂度 | 稳定性 |
|---|---|---|---|---|---|
| 冒泡排序 | O(n) | O(n^2) | O(n^2) | O(1) | 稳定 |
| 插入排序 | O(n) | O(n^2) | O(n^2) | O(1) | 稳定 |
| 选择排序 | O(n^2) | O(n^2) | O(n^2) | O(1) | 不稳定 |
| 希尔排序 | O(n) | O(n^1.3) | O(n^2) | O(1) | 不稳定 |
| 堆排序 | O(n * log(n)) | O(n * log(n)) | O(n * log(n)) | O(1) | 不稳定 |
| 快速排序 | O(n * log(n)) | O(n * log(n)) | O(n^2) | O(log(n)) ~ O(n) | 不稳定 |
| 归并排序 | O(n * log(n)) | O(n * log(n)) | O(n * log(n)) | O(n) | 稳定 |
八、其他非基于比较排序：
我们首先先来说下计数排序，这种排序其实我们之前很多时候已经了解过思想了。计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤就是先统计相同元素出现次数，再根据统计的结果将序列回收到原来的序列中。
计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。它的时间复杂度为O(MAX(N,范围))，空间复杂度则为O(范围)，是一种稳定的算法。我的代码如下：
java
public static void countSort(int[] array) {
int maxVal = array[0];
int minVal = array[0];
for(int i = 1; i < array.length; i++){
if(array[i] > maxVal){
maxVal = array[i];
}
if(array[i] < minVal){
minVal = array[i];
}
}
int len = maxVal - minVal + 1;
int[] count = new int[len];
for(int i = 0; i < array.length; i++){
int index = array[i];
count[index - minVal]++;
}
int index = 0;
for(int i = 0; i < count.length; i++){
while(count[i] != 0){
array[index++] = i + minVal;
index++;
count[i]--;
}
}
}如果想更深入了解，可以参考下面的文章：计数排序 - 知乎
我们还有桶排序和基数排序两种排序，之后会再进行讲解。
总结
本文详细介绍了Java中常见的排序算法实现与性能分析。主要内容包括排序的定义、稳定性区分、内部与外部排序的分类，以及常见应用场景。核心排序算法，包括插入类，直接插入排序（O(n²)稳定）和更高效的希尔排序（O(n^1.25)不稳定）；选择类，简单选择排序（O(n²)不稳定）和堆排序（O(nlogn)不稳定）；交换类，冒泡排序（O(n²)稳定）和快速排序（优化后达O(nlogn)不稳定），重点讲解了Hoare、挖坑法和前后指针三种分区实现，以及三数取中、递归优化和非递归改造三种优化策略；归并排序，递归与非递归实现（O(nlogn)稳定但需O(n)空间）。通过实验数据比较各算法在有序/无序数组下的耗时，展示快速排序的优越性，并提供IDEA调整栈大小的方法解决递归深度问题。并且表格对比七种算法的时空复杂度及稳定性，并简要提及计数排序等非比较排序。全文通过代码示例、复杂度分析和性能测试，系统性地展示了排序算法的实现要点与适用场景。