十大排序算法——实现程序

//冒泡排序
//它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来
//每循环一次，最大值移到最右边
void bubble_sort(int* arr, int len) {
    int i, j, temp;
    for (i = 0; i < len - 1; i++) {
        for (j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
}


//选择排序
//首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
//然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
//以此类推，直到所有元素均排序完毕。
void selection_sort(int* arr, int len) {
    int i, j, temp, min;
    for (i = 0; i < len; i++) {
        min = i;
        for (j = i; j < len; j++) {
            if (arr[min] > arr[j]) {
                min = j;
            }
        }
        if (min != i) {
            temp = arr[min];
            arr[min] = arr[i];
            arr[i] = temp;
        }
    }
}


//插入排序
//通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
void insert_sort(int* arr, int len) {
    int temp, i, j;
    for (i = 1; i < len; i++) {
        temp = arr[i];
        for (j = i - 1; j >= 0 && arr[j] > temp; j--) {
            arr[j + 1] = arr[j];
        }
        arr[j + 1] = temp;
    }
}


//希尔排序——进阶版插入排序
//先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，
//待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序
void shell_sort(int* arr, int len) {
    int i, j, gap;
    int temp;
    for (gap = len >> 1; gap > 0; gap >>= 1) {
        for (i = gap; i < len; i++) {
            temp = arr[i];
            for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap) {
                arr[j + gap] = arr[j];
            }
            arr[j + gap] = temp;
        }
    }
}


//快速排序——递归法
void swap(int* a, int* b) { //交换数值
    int temp = *a;
    *a = *b;
    *b = temp;
}

void quick_sort_recursive(int *arr, int start, int end) {
    if (start >= end) {
        return;
    }
    int mid = arr[end];
    int left = start, right = end - 1;
    while (left < right) {
        while (arr[left] < mid && left < right) {
            left++;
        }
        while (arr[right] > mid && left < right) {
            right--;
        }
        swap(&arr[left], &arr[right]);
    }
    if (arr[left] > arr[end]) {
        swap(&arr[left], &arr[end]);
    }
    else
    {
        left++;
    }
    if (left) {
        quick_sort_recursive(arr, start, left - 1);
    }
    quick_sort_recursive(arr, left + 1, end);
}

void quick_sort(int* arr, int len) {
    quick_sort_recursive(arr, 0, len - 1);
}


//计数排序
void counting_sort(int* arr, int *sorted_arr, int len) {
    int* count_arr = (int*)malloc(sizeof(int) * 100);
    memset(count_arr, 0, sizeof(int) * 100);
    int k = 0;
    for (int i = 0; i < len; i++) {
        count_arr[arr[i]]++;
    }
    for (int j = 0; j < 100; j++) {
        while (count_arr[j] != 0) {
            sorted_arr[k++] = j;
            count_arr[j]--;
        }
    }
    free(count_arr);
}