几种常见的排序方法

最经典的冒泡排序法

for (int i = 0; i < array.length - 1; i++) {
        boolean isSorted = true;
        for (int j = 0; j < array.length - i - 1; j++) {
            if (array[j] > array[j + 1]) {
                swap(array, j, j + 1);
                isSorted = false;
            }
        }
        if (isSorted) {
            break;
        }
    }

可能是最重要的排序方法--快速排序

public int findKth(int[] a, int low, int high, int k) {
     int part = partation(a, low, high);
     
     if(k == part - low + 1) return a[part];
     else if(k > part - low + 1) return findKth(a, part + 1, high, k - part + low -1);
     else return findKth(a, low, part -1, k);    
     
 }
 public int partation(int[] a, int low, int high) {
     int key = a[low];
     while(low < high) {
         while(low < high && a[high] <= key) high--;
         a[low] = a[high];
         while(low < high && a[low] >= key) low++;
         a[high] = a[low];
     }
     a[low] = key;
     return low;
 }

稳定排序中最快的排序---归并排序

public static void mergeSort(int[] array) {
    mergeSortInternal(array, 0, array.length);
}

private static void mergeSortInternal(int[] array, int low, int high) {
    if (low >= high - 1) {
        return;
    }
    
    int mid = (low + high) / 2;
    mergeSortInternal(array, low, mid);
    mergeSortInternal(array, mid, high);
    
    merge(array, low, mid, high);
}

最方便的排序 --- 插入排序

public static void insertSort(int[] array) {
    for (int i = 1; i < array.length; i++) {
        // 有序区间: [0, i)
        // 无序区间: [i, array.length)
        int v = array[i];   // 无序区间的第一个数
        int j = i - 1;
        // 不写 array[j] == v 是保证排序的稳定性
        for (; j >= 0 && array[j] > v; j--) {
            array[j + 1] = array[j];
        }
        array[j + 1] = v;
    }
}