首先看一下幾種常見排序的特性

插入排序

void insertSort(vector<int> & arr)
{
    int sz = arr.size();
    int tmp;
    for (int i = 1; i < sz; ++i){
        tmp = arr[i];
        int j;
        for (j = i; j > 0 && tmp < arr[j - 1]; j--)
            arr[j] = arr[j - 1];
        arr[j] = tmp;
    }
}
 

快速排序

//注意如果採取的是三數中值分割法的時候需要，將頭，中，尾的三個值中間的轉移到陣列的頭部。這樣來進行partition
void quickSort(vector<int> & arr, int start, int end)
{
    if (start >= end)
        return;
    int pivot = getPartion(arr, start, end);
    quickSort(arr, start, pivot - 1);
    quickSort(arr, pivot + 1, end);
}


void
 
 bubbleSort(vector<int> & arr)
{
    int sz = arr.size();
    for (int i = sz - 1; i > 0; --i){
        for (int j = 0; j < i; ++j){ //邊界需要注意一下
            if (arr[j] > arr[j + 1])
                swap(arr[j], arr[j+1]);
        }
    }
}

希爾排序

void shellSort(vector<int> & arr)
{
    int
 
 sz = arr.size();
    for (int gap = sz / 2; gap > 0; gap /= 2){
        int tmp;
        for (int i = gap; i < sz; ++i){//每次和保證自己同樣的間隔組中資料是有序的，然後再使用插入排序的思想
            tmp = arr[i];
            int j;
            for (j = i; j >= gap && tmp < arr[j - gap]; j -= gap){
                arr[j] = arr[j - gap];
            }
            arr[j] = tmp;
        }
    }
}

堆排序

int up(int i){
    return (i - 1) / 2; //堆節點從0開始計算
}

int down(int i){
    return i * 2 + 1; //左節點
}

//新增資料用
void minHeapFixUp(vector<int> & arr, int i)//i代表插入的位置
{
    int j = up(i);
    int tmp = arr[i];
    while (j >= 0 && i != 0){
        if (arr[j] <= arr[i])
            break; //停止調整
        arr[i] = arr[j];
        i = j;
        j = up(i);
    }
    arr[i] = tmp;
}

//刪除資料用，實際上是通過刪除操作來調整堆
void minHeapFixDown(vector<int> & arr, int i, int n)
{
    int tmp = arr[i];
    int j = down(i);
    while (j < n){
        if (j + 1 < n && arr[j] > arr[j + 1])
            j++;
        if (tmp <= arr[j])
            break;
        arr[i] = arr[j];
        i = j;
        j = down(j);
    }
    arr[i] = tmp;
}

void makeHeap(vector<int> & arr)
{
    int sz = arr.size();
    //從sz/2 - 1開始建堆的目的是因為對於堆來說，有sz/2 + 1個節點是葉子節點，
    //由於其左右不存在子節點，不需要向下調整，所以從非葉子節點開始向下調整
    for (int i = sz / 2 - 1; i >= 0; --i){
        minHeapFixDown(arr, i, sz);
    }
}

void heapSort(vector<int> & arr)//最小堆得到降序排序
{
    int sz = arr.size();
    makeHeap(arr);
    for (int i = sz - 1; i > 0; --i){
        swap(arr[0], arr[i]); //得到最小的一個數
        minHeapFixDown(arr, 0, i);
    }
}

歸併排序

void merge(vector<int> & arr, vector<int> & copy, int start, int mid, int end)
{
    int p = start, q = mid + 1, i = start;
    while (p <= mid && q <= end){
        if (arr[p] < arr[q])
            copy[i++] = arr[p++];
        else
            copy[i++] = arr[q++];
    }
    while (p <= mid)
        copy[i++] = arr[p++];
    while (q <= end)
        copy[i++] = arr[q++];
    while (start <= end){
        arr[start] = copy[start];
        start++; //注意這裡一定要分開寫  而不要合在一起，容易加兩次出錯
    }
}

void mergeSort(vector<int> & arr, vector<int> & copy, int start, int end)
{
    if (start < end){
        int mid = (start + end) >> 1;
        mergeSort(arr, copy, start, mid);
        mergeSort(arr, copy, mid + 1, end);
        merge(arr, copy, start, mid, end);
    }
}

void mergeSort(vector<int> & arr)
{
    vector<int> copy(arr);
    int sz = arr.size();
    int mid = sz / 2;
    mergeSort(arr, copy, 0, mid);
    mergeSort(arr, copy, mid + 1, sz - 1);
    merge(arr, copy, 0, mid, sz - 1);
}

直接選擇排序

void selectSort(vector<int> & vec){
    int sz = vec.size();
    int minPos;
    for (int i = 0; i < sz - 1; ++i){
        minPos = i;
        for (int j = i + 1; j < sz; ++j){
            if (vec[j] < vec[minPos])
                minPos = j;
        }
        swap(vec[i], vec[minPos]);
    }
}

基數排序

• 分別按照個位，十位，百位。。。來進行桶排序，得到最終結果就是正確的結果

public class RadixSort {
    // 獲取x這個數的d位數上的數字
    // 比如獲取123的1位數，結果返回3
    public int getDigit(int x, int d) {
        int a[] = {
                1, 1, 10, 100
        }; // 本例項中的最大數是百位數，所以只要到100就可以了
        return ((x / a[d]) % 10);
    }
    public void radixSort(int[] list, int begin, int end, int digit) {
        final int radix = 10; // 基數
        int i = 0, j = 0;
        int[] count = new int[radix]; // 存放各個桶的資料統計個數
        int[] bucket = new int[end - begin + 1];
        // 按照從低位到高位的順序執行排序過程
        for (int d = 1; d <= digit; d++) {
            // 置空各個桶的資料統計
            for (i = 0; i < radix; i++) {
                count[i] = 0;
            }
            // 統計各個桶將要裝入的資料個數
            for (i = begin; i <= end; i++) {
                j = getDigit(list[i], d);
                count[j]++;
            }
            // count[i]表示第i個桶的右邊界索引
            for (i = 1; i < radix; i++) {
                count[i] = count[i] + count[i - 1];
            }
            // 將資料依次裝入桶中
            // 這裡要從右向左掃描，保證排序穩定性
            for (i = end; i >= begin; i--) {
                j = getDigit(list[i], d); // 求出關鍵碼的第k位的數字， 例如：576的第3位是5
                bucket[count[j] - 1] = list[i]; // 放入對應的桶中，count[j]-1是第j個桶的右邊界索引
                count[j]--; // 對應桶的裝入資料索引減一
            }
            // 將已分配好的桶中資料再倒出來，此時已是對應當前位數有序的表
            for (i = begin, j = 0; i <= end; i++, j++) {
                list[i] = bucket[j];
            }
        }
    }
    public int[] sort(int[] list) {
        radixSort(list, 0, list.length - 1, 3);
        return list;
    }
    // 列印完整序列
    public void printAll(int[] list) {
        for (int value : list) {
            System.out.print(value + "\t");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        int[] array = {
                50, 123, 543, 187, 49, 30, 0, 2, 11, 100
        };
        RadixSort radix = new RadixSort();
        System.out.print("排序前:\t\t");
        radix.printAll(array);
        radix.sort(array);
        System.out.print("排序後:\t\t");
        radix.printAll(array);
    }
}