C语言排序算法

reference:十大经典排序算法（C语言实现）_c语言排序算法-CSDN博客

1. 冒泡法

1.1 原理：

以从小到大排序为例：相邻元素两两进行比较；结果是较大的元素从最右边开始往左连续放置。

n个元素，需要n轮比较；每轮需要n - i -1次两两比较。

从小到大排序为例：

1）经过第一轮的比较，就可以找到最大的元素，并将它移动到最后一个位置。

2）第一轮结束后，继续第二轮。仍然从数组头部开始比较，让较大的元素逐渐往后移动，直到数组的倒数第二个元素为止。经过第二轮的比较，就可以找到次大的元素，并将它放到倒数第二个位置。

3）以此类推，进行 n-1（n 为数组长度）轮“冒泡”后，就可以将所有的元素都排列好。

每比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边开始x冒出来。从而形成一个以最右边元素开始向左有序的数列。也就是说名经过一轮排序，有序数列都列在右半部分，所以下一次只需要排左半部分无序的就好了。

如果有 n 个数据，那么只需要比较 n–1 轮。而且除了第一轮之外，每轮都不用全部比较。因为经过前面轮次的比较，已经比较过的轮次已经找到该轮次中最大的数并浮到右边了，所以右边的数不用比较也知道是大的。

如果某一轮所有两两比较都没有进行数据交换，说明整个序列已经是有序拍好的了，所以，也无需继续比较了。

1.2 C语言demo

void sort_bubble(int * arr, int length) {
    for (int i = 0; i < length; i++) {
        int swap_flag = 1; //假定整个数组已经排序好了
        //因为最右边的都已经排序完成了，所以不需要再遍历了
        //所以判断为j < length -i -1，当然j < length -1也正确
        //只是多了无畏的遍历比较
        for (int j = 0; j < length -i - 1; j ++) {
            if (arr[j] > arr[j + 1]) swap(&arr[j], &arr[j + 1]);
            swap_flag = 0; //说明数组还没有排序完成
        }
        //如果这一轮没有发生元素交换，
        //说明从最右边到最左边都已经排序好了，
        //所以没有必要再继续下一轮了，所以可以直接return
        if (swap_flag) return;
    }
}
 

2. 选择排序法

2.1 原理

以从小到大排序为例：相邻两元素两两比较，选出较小的放在左边，较小的依次从左往右放置。

2.2 C语言demo

//选择排序法：某一轮所有两两比较都没有进行交换，则说明已经拍好序，不需要再迭代了
void sort_select(int *arr, int length) {
    bool is_sorted = true; //假设已经排序好了
    for (int i = 0; i < length; i++) {
        is_sorted = true;
        for (int j = i; j < length - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(&arr[j], &arr[j + 1]);
                is_sorted = false; //还没有拍好序
            }
        }
        if (is_sorted) return;
    }
}

3 交换排序法

3.1 原理

//交换排序法：从小到大排序为例：最左侧的数与相邻的右边的数比较，大于则交换；

//继续最左面的数和相邻相邻的右边的数比较，大于则交换，依次迭代

//这个不是相邻的两两比较，而是左边的数，跟右边所有的数依次比较

//左边是有序数列，右半边是需要继续排序的数列

3.2 C语言demo

//交换排序法：从小到大排序为例：最左侧的数与相邻的右边的数比较，大于则交换；
//继续最左面的数和相邻相邻的右边的数比较，大于则交换，依次迭代
//这个不是相邻的两两比较，而是左边的数，跟右边所有的数依次比较
//左边是有序数列，右半边是需要继续排序的数列
void sort_exchange (int *arr, int length) {
    for (int i = 0; i < length; i++) {
        for (int j = i + 1; j < length; j++) {
            if (arr[i] > arr[j]) {
                swap(&arr[i], &arr[j]);
            }
        }
    }
}

4. 所有算法完整的demo例子

//date: 20240331
//author: tianqiang
#include <stdio.h>
#include <string.h>
#include <stdbool.h>

void swap(int *a, int* b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}
//冒泡排序法：某一轮所有两两比较都没有进行交换，则说明已经拍好序，不需要再迭代了
void sort_bubble(int * arr, int length) {
    for (int i = 0; i < length; i++) {
        int swap_flag = 1; //假定整个数组已经排序好了
        //因为最右边的都已经排序完成了，所以不需要再遍历了
        //所以判断为j < length -i -1，当然j < length -1也正确
        //只是多了无畏的遍历比较
        for (int j = 0; j < length -i - 1; j ++) {
            if (arr[j] > arr[j + 1]) swap(&arr[j], &arr[j + 1]);
            swap_flag = 0; //说明数组还没有排序完成
        }
        //如果这一轮没有发生元素交换，
        //说明从最右边到最左边都已经排序好了，
        //所以没有必要再继续下一轮了，所以可以直接return
        if (swap_flag) return;
    }
}
//选择排序法：某一轮所有两两比较都没有进行交换，则说明已经拍好序，不需要再迭代了
void sort_select(int *arr, int length) {
    bool is_sorted = true; //假设已经排序好了
    for (int i = 0; i < length; i++) {
        is_sorted = true;
        for (int j = i; j < length - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(&arr[j], &arr[j + 1]);
                is_sorted = false; //还没有拍好序
            }
        }
        if (is_sorted) return;
    }
}
//交换排序法：从小到大排序为例：最左侧的数与相邻的右边的数比较，大于则交换；
//继续最左面的数和相邻相邻的右边的数比较，大于则交换，依次迭代
//这个不是相邻的两两比较，而是左边的数，跟右边所有的数依次比较
//左边是有序数列，右半边是需要继续排序的数列
void sort_exchange (int *arr, int length) {
    for (int i = 0; i < length; i++) {
        for (int j = i + 1; j < length; j++) {
            if (arr[i] > arr[j]) {
                swap(&arr[i], &arr[j]);
            }
        }
    }
}
void display(int *arr, int length) {
    for (int i = 0; i < length; i++) {
        printf("%d, ", arr[i]);
    }
    printf("\n");
}
int main() {
    int a[] = {1, 3, 6, 2, 7};
    sort_bubble(a, sizeof(a)/sizeof(int));
    sort_select(a, sizeof(a)/sizeof(int));
    sort_exchange(a, sizeof(a)/sizeof(int));
    display(a, sizeof(a)/sizeof(int)); 
    return 0;
}