排序

一 稳定排序

①插入排序：
将数据序列分成两部分（无序部分和有序部分），从无序序列依次取值向有序序列插入即可。

最坏时间复杂度o（n²），最好时间复杂度o（n）

②冒泡排序：
（按从小到大的顺序）从头到尾比较，若前面的元素比后面的元素大，则交换，否则，索引往后走，直到遍历完全部元素。

最坏时间复杂度o（n²），最好时间复杂度o（n）

冒泡排序的优化：

③归并排序：
采用分治思想，将问题进行拆解排序再合并。

归并排序的时间复杂度为o（nlogn）
拓展：当我们处理数据量比较大的数据分类时，由于电脑系统内存限制，我们需要把数据进行分别排序，然后再进行合并，因此归并排序又属于外部排序。

代码实现

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>

#define swap(a, b){\
    a ^= b; b ^= a; a ^= b;\
}

#define TEST(arr, n, func, args...){\
    int *num = (int *)malloc(sizeof(int) * n);\
    memcpy(num, arr, sizeof(int) * n);\
    output(num, n);\
    printf("%s = ", #func);\
    func(args);\
    output(num, n);\
    free(num);\
}

void insert_sort(int *num, int n){
    for(int i = 1; i < n; i++){
        for(int j = i; j > 0 && num[j] < num[j - 1]; j--){
            swap(num[j], num[j - 1]);
        }
    }
}

void bubble_sort(int *num, int n){
    int times = 1;
    for(int i = 1; i < n && times; i++){
        times = 0;
        for(int j = 0; j < n - i; j++){
            if(num[j] > num[j + 1]){
                swap(num[j], num[j + 1]);
                times++;
            }
        }
    }
}

void merge_sort(int *num, int l, int r){
    if(r - l <= 1){
        if(r - l == 1 && num[l] > num[r]){
            swap(num[l], num[r]);
        }
        return ;
    }
    int mid = (l + r) >> 1;
    merge_sort(num, l, mid);
    merge_sort(num, mid + 1, r);
    int *temp = (int *)malloc(sizeof(int) * (r - l + 1));
    int p1 = l, p2 = mid + 1, k  = 0;
    while(p1 <= mid || p2 <= r){
        if(p2 > r || (p1 <= mid && num[p1] <= num[p2])){
            temp[k++] = num[p1++];
        }else{
            temp[k++] = num[p2++];
        }
    }
    memcpy(num + l, temp, sizeof(int) * (r - l + 1));
    free(temp);
    return ;
}

void randint(int *arr, int n){
    while(n--) arr[n] = rand() % 100;
    return ;
}

void output(int *num, int n){
    printf("[");
    for(int i = 0; i < n; i++){
        printf(" %d", num[i]);
    }
    printf("]\n");
}

int main(){
    srand(time(0));
    #define max_op 20
    int arr[max_op];
    randint(arr, max_op);
    TEST(arr, max_op, insert_sort,num, max_op);
    TEST(arr, max_op, bubble_sort,num, max_op);
    TEST(arr, max_op, merge_sort,num, 0, max_op - 1);
    return 0;
}

二 不稳定排序

①选择排序
将数组划分为两部分，选择待排序的元素中最小的元素，插入到已排序序列的末尾。
时间复杂度为o（n²）

②快速排序
完全逆序的时候，时间复杂度为o（n²）

快排优化核心代码：

void quick_sort(int *num, int l, int r) {
    while (l < r) {
        int x = l, y = r, z = num[(l + r) >> 1];
        do {
            while (x <= y && num[x] < z) x++;
            while (x <= y && num[y] > z) y--;
            if (x <= y) {
                swap(num[x], num[y]);
                x++, y--;
            }
        } while (x <= y);
        quick_sort(num, x, r);
        r = y;
    }
    return ;
}

代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define swap(a, b) {\
    __typeof(a) __temp = a;\
    a = b; b = __temp;\
}

#define TEST(arr, n, func, args...) {\
    int *num = (int *)malloc(sizeof(int) * n);\
    memcpy(num, arr, sizeof(int) * n);\
    output(num, n);\
    printf("%s = ", #func);\
    func(args);\
    output(num, n);\
    free(num);\
}

void select_sort(int *num, int n) {
    for (int i = 0; i < n - 1; i++) {
        int ind = i;
        for (int j = i + 1; j < n; j++) {
            if (num[ind] > num[j]) ind = j;
        }
        swap(num[i], num[ind]);
    }
    return ;
}

void quick_sort(int *num, int l, int r) {
    if (r < l) return ;
    int x = l, y = r, z = num[l];
    while (x < y) {
        while (x < y && num[y] >= z) y--;
        if (x < y) num[x++] = num[y];
        while (x < y && num[x] <= z) x++;
        if (x < y) num[y--] = num[x];
    }
    num[x] = z;
    quick_sort(num, l, x - 1);
    quick_sort(num, x + 1, r);
    return ;
}

void randint(int *arr, int n) {
    while (n--) arr[n] = rand() % 100;
    return ;
}

void output(int *num, int n) {
    printf("[");
    for (int i = 0; i < n; i++) {
        printf(" %d", num[i]);
    }
    printf("]\n");
    return ;
}

int main() {
    srand(time(0));
    #define max_op 20
    int arr[max_op];
    randint(arr, max_op);
    TEST(arr, max_op, select_sort, num, max_op);
    TEST(arr, max_op, quick_sort, num, 0, max_op - 1);
    return 0;
}