基本排序算法代码实现，以及使用场景推荐

1. 冒泡排序　

平均复杂度为 O(n^2),  稳定

    // 冒泡排序
    public static void Bubble_Sort(int[] A, int n){
        int flag = 0;
        // 进行 n - 1 轮冒泡
        for(int i = n - 1; i > 0; i--){
            flag = 0;
            for(int j = 0; j < i; j++){
                if(A[j] > A[j + 1]){
                    // 交换 A[j] 和 A[j + 1]
                   A[j] ^= A[j + 1];
                   A[j + 1] ^= A[j];
                   A[j] ^= A[j + 1];
                   flag = 1;
                }
            }
            if(flag == 0)   // 此轮没发生交换，排序结束
                break;
        }
    }

2. 插入排序

最好情况是 序列本身有序，此时复杂度为 O(n), 但是平均复杂度为 O(n^2),  稳定，适合 序列中的元素相对有序的场景

// 插入排序
public static void Insertion_Sort(int[] A, int n){
    int temp, i, j;
    for(i = 1; i < n; i++){
        temp = A[i];
        for(j = i; j > 0 && A[j - 1] > temp; j--){
            A[j] = A[j - 1];
        }
        A[j] = temp;
    }
}

3. 希尔排序

平均复杂度 为 O(n^d), 不稳定

// 希尔排序， 最坏情况 为 O(n^2)
static void Shell_Sort(int A[], int n){
    int d,i, j, temp;     // d 为增量
    for(d = n / 2; d > 0; d /= 2){
        // 内部是一个增量为 d 的插入排序
        for(i = d; i < n; i++){
            temp = A[i];
            for(j = i; j >= d && A[j - d] > temp; j -= d)
                A[j] = A[j - d];
            A[j] = temp;
        }
    }
}

4. 堆排序

平均复杂度为 O(nlogn) , 不稳定

// 堆排序
public static void downAdjust(int[] A, int p, int n){
    int parent, child = p;
    int x = A[p];           // 取出根节点的值
    for(parent = p; (2 * parent + 1) < n; parent = child){
        child = 2 * parent + 1;
        // 如果右孩子存在且比左孩子大
        if(child + 1 < n && A[child + 1] > A[child]){
            child++;
        }
        if(x >= A[child])        // 与最大孩子结点比较, 如果父节点大，说明找到了位置
            break;
        else
            A[parent] = A[child];   // 否则让最大孩子上位
    }
    A[parent] = x;      // 退出循环说明找到了 p 的位置
}

public static void Heap_Sort(int[] A, int n){
    // 建立最大堆
    for(int i = n / 2 - 1; i >= 0; i--){ // 从第一个右孩子的结点向下调整
        downAdjust(A, i, n);
    }
    for(int i = n - 1; i > 0; i--){
        // 将堆顶元素与当前未排序的最后一个元素交换
        int temp = A[i];
        A[i] = A[0];
        A[0] = temp;
        downAdjust(arr, 0, i);
    }
}

5. 选择排序

平均复杂度 O(n^2), 不稳定，如序列：2 2  3 4 5 1

// 选择排序， 最坏情况为 O(n^2), 不稳定 如 2 2 3 4 5 1
public static void Selection_Sort(int[] A, int n){
    int k, temp;
    for(int i = 0; i < n - 1; i++){
        k = i;
        for(int j = i + 1; j < n; j++){
            if(A[j] < A[k])
                k = j;      // 找到最小的元素的下标
        }
        temp = A[k];
        A[k] = A[i];
        A[i] = temp;
    }
}

6. 归并排序

平均复杂度为 O(nlogn), 额外空间复杂度为 O(n), 稳定

public static void Merge(int[] A, int[] temp, int LL, int LR, int RL, int RR){
    int left = LL;
    int index = LL;
    while(LL <= LR && RL <= RR) {
        if (A[LL] <= A[RL]) {
            temp[index++] = A[LL++];
        } else {
            temp[index++] = A[RL++];
        }
    }
    while(LL <= LR)
        temp[index++] = A[LL++];
    while(RL <= RR)
        temp[index++] = A[RL++];

    // 将temp元素 复制到 A 数组中
    for(int i = left; i < index; i++)
        A[i] = temp[i];

}

public static void Msort(int[] A, int temp[], int left, int right){
    int center;
    if(left < right){
        center = (right + left) / 2;
        Msort(A, temp, left, center);       // 归并做半段元素
        Msort(A, temp, center + 1, right);  // 归并y右半段元素
        Merge(A, temp, left, center, center + 1, right);    // 合并左右两段
    }
}

// 归并排序 递归方式 复杂度为 O(nlogn)
public static void MergeSort(int[] A, int n){
    int[] temp = new int[1000];         // 借助一个辅助富足，每次将两段区间排好序的元素存在temp数组总
    Msort(A, temp, 0, n - 1);
}

7. 快速排序

平均复杂度为 O(nlogn), 不稳定

// 随机选取主元，对区间 [left, right] 进行划分
public static int randPartition(int[] A, int left, int right){
    // 生成一个 [left, right] 范围内的随机数, 随机让排序平均复杂度更低
    Random r = new Random();
    int p = r.nextInt(right - left) + left;

    int temp = A[left];
    A[left] = A[p];
    A[p] = temp;

    int pivot = A[left];
    while(left < right){    // 只要 left 与 right 不相遇
        while(left < right && A[right] > pivot)
            right--;
        A[left] = A[right];
        while(left < right && A[left] <= pivot)
            left++;
        A[right] = A[left];
    }
    A[left] = pivot;
    return left;
}

// 快速排序， left 与 right 初值为序列首尾下标
public static void quickSortHelp(int[] A, int left, int right){
    if(left < right){   // 当区间长度超过 1 时
        // 将 [left, right] 按照 A[left] 为主元，一分为二
        int pos = randPartition(A, left, right);
        quickSortHelp(A, left, pos - 1);
        quickSortHelp(A, pos + 1, right);
    }
}

public static void quickSort(int[] A, int n){
    quickSortHelp(A, 0, n - 1);
}

算法比较：

 不同场景的排序算法选择：

如果序列相对有序，则选择 插入排序；

如果 序列分布散乱随机，则用归并排序或者快速排序；

如果序列元素都限定在某个范围内，则用基数排序；

如果要求排序稳定，则选用归并排序或插入排序或基数排序