排序模板

插入排序： 直接插入排序 折半插入排序 希尔排序

交换排序： 冒泡排序 快速排序

选择排序 ：简单选择排序 堆排序

归并排序
基数排序

图片来源

冒泡排序

void bubbleSort(int a[], int n){
    for(int i = 1; i < n; i++){
        for(int j = n-1; j >= i; j--){
            if(a[j] < a[j-1]){
                swap(a[j], a[j-1]);
            }
        }        
    }
}

简单选择排序

void selectSort(int a[], int n){
    for(int i = 0; i < n; i++){
        int min = i;
        for(int j = i+1; j < n; j++){
            if(a[min] > a[j]){
                min = j;
            }
        }
        swap(a[i], a[min]); 
    }
}

直接插入排序

void insertSort(int a[], int n){
    for(int i = 1; i < n; i++){
        int temp = a[i], j = i;
        while(j > 0 && a[j-1] > temp){
            a[j] = a[j-1];
            j--;
        }
        a[j] = temp;

    }
}

折半插入排序

void BinaryInsertSort(int a[], int n){
    int i, j, low, high, key, mid;
    for(i = 1; i < n; i++) {
        low = 0;
        high = i - 1;
        key = a[i];
        while (low <= high) {
            int mid = (low + high) / 2;
            if (key >= a[mid]) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        for (j = i - 1; j > high; j--) {
            a[j + 1] = a[j];
        }
        a[j + 1] = key;
    }
}

快速排序

详解与优化

void quickSort(int a[], int low, int high)
{
    if(low >= high)
    {
        return;
    }
    int first = low;
    int last = high;
    int key = a[first];/*用字表的第一个记录作为枢轴*/

    while(first < last)
    {
        while(first < last && a[last] >= key)
        {
            --last;
        }

        a[first] = a[last];/*将比第一个小的移到低端*/

        while(first < last && a[first] <= key)
        {
            ++first;
        }

        a[last] = a[first];  /*将比第一个大的移到高端*/

    }
    a[first] = key;/*枢轴记录到位*/
    

    quickSort(a, low, first-1);
    quickSort(a, first+1, high);
}

堆排序

详解

void downAdjust(int low, int high) {
    int i = low, j = i * 2;
    while(j <= high) {
        if(j + 1 <= high && a[j + 1] > a[j]) {
            j = j + 1;
        }
        if(a[j] > a[i]) {
            swap(a[j], a[i]);
            i = j;
            j = i * 2;
        } else {
            break;
        }
    }
}
void heapSort(int a[], int n) {     
    for(int i = n / 2; i >= 0; i--){       // 建堆
        downAdjust(i, n-1);
    }
    for(int i = n-1; i > 0; i--) {
        swap(a[i], a[0]);   //交换heap[i] 与 堆顶
        downAdjust(0, i - 1);
    }
}

归并排序

详解

void mergeSort(int a[],int l,int r,int mid){

    int aux[r-l+1], i, j, k;

    for(k=l; k<=r; k++)
        aux[k-l]=a[k];

    i=l;
    j=mid+1;
    for(k=l; k<=r; k++){
        if(i>mid){
            a[k]=aux[j-l];
            j++;
        }else if(j>r){
            a[k]=aux[i-l];
            i++;
        }else if(aux[i-l]>aux[j-l]){
            a[k]=aux[j-l];
            j++;
        }else{
            a[k]=aux[i-l];
            i++;
        }
    }
} 
void merge_sort(int a[], int l, int r) { 
    if (l >= r){
        return;
    }

    int mid = (l + r) / 2;

    merge_sort(a, l, mid);
    merge_sort(a, mid + 1, r);
    mergeSort(a, l, r, mid);
}

希尔排序

详解

void shellSort(int a[], int n){   // 数组下标 1 ~ n
    int i, j;
    int increment = n;
    do{
        increment = increment / 3 + 1;
        for(i = increment + 1; i <= n; i++){
            if(a[i] < a[i-increment]){
                a[0] = a[i];  //暂存在a[0]
                for(j = i-increment; j > 0 && a[0] < a[j]; j -= increment)
                    a[j+increment] = a[j];
                a[j+increment] = a[0];
            }
        }

    }while (increment > 1);
}

基数排序

详解

void radixSort(int a[], int n){
    int maxn = a[0];
    for(int i = 1; i < n; i ++){
        maxn = max(a[i], maxn);
    }
    int d = 0;
    while(maxn){
        d++;
        maxn /= 10;
    }
    d = pow(10, d);
    int k = 1;
    int t[10][n];   //桶
    for(int i = 0; i < 10; i++)
        for(int j = 0; j < n; j++)
            t[i][j] = 0;
    int num[n]; //记录每个桶中存入数的个数
    for(int i = 0; i < n; i++)
        num[i] = 0;
    while(k < d){
        for(int i = 0; i < n; i++){
            int m = (a[i] / k) % 10;
            t[m][num[m]] = a[i];
            num[m]++;
        }
        int c = 0;
        for(int i = 0; i < n; i++){
            if(num[i] != 0){
                for(int j = 0; j < num[i]; j++){
                    a[c++] = t[i][j];
                }
            }
            num[i] = 0;
        }
        k = k * 10;
    }
}