常见算法的C语言实现

1. 冒泡排序
冒泡排序（Bubble Sort）就是一种交换排序，它的思想就是两个元素进行比较，如果是反序则交换，直到没有反序的元素为止。

#include <stdio.h>
//两个数进行交换的函数
void Swap(int *num1, int *num2)
{
    int temp = *num1;
    *num1 = *num2;
    *num2 = temp;
}
//冒泡排序的具体实现
void bubbleSort(int arr[], int len)
{
    for (int i = 0; i < len - 1; ++i)
    {
        for (int j = i + 1; j <= len  - 1; ++j)
        {
            if (arr[i] < arr[j])
            {
                Swap(&arr[i], &arr[j]);
            }
        }
    }
}
//打印函数
void Print(int arr[], int len)
{
    for (int i = 0; i < len; ++i)
    {
        printf("%d ", arr[i]);
    }
}
int main(void)
{
    int arr[] = {1,9,7,2,4,3,6,5,0,8};
    //求出数组的长度
    int len = sizeof(arr) / sizeof(int);
    printf("排序之前：\n");
    Print(arr, len);
    bubbleSort(arr, len);
    printf("\n");
    printf("排序之后：\n");
    Print(arr, len);
    return 0;
}

2. 选择排序
   选择排序（Selection Sort）的思想就是在一直的元素中找到最大（小）的值放在起始的位置，再从剩余的元素中找到最大（小）的元素放在刚刚找到的最值得后面，以此类推，直到所有的元素全部排序结束。

#include <stdio.h>
void Swap(int *num1, int *num2)
{
    int temp = *num1;
    *num1 = *num2;
    *num2 = temp;
}
void Print(int arr[], int len)
{
    for (int i = 0; i < len; ++i)
    {
        printf("%d ", arr[i]);
    }
}
void SelectionSort(int arr[], int len)
{
    for (int i = 0; i < len - 1; i++)
    {
        int min = i;
        for (int j = i + 1; j < len; j++)
        {
            if (arr[min] > arr[j])
            {
                min = j;
            }
        }
        if (i != min)
        {
            Swap(&arr[i], &arr[min]);
        }
    }
}
int main(void)
{
    int arr[] = {1,9,7,2,4,3,6,5,0,8};
    int len = sizeof(arr) / sizeof(int);
    printf("排序之前：\n");
    Print(arr, len);
    SelectionSort(arr, len);
    printf("\n");
    printf("排序之后：\n");
    Print(arr, len);
    return 0;
}

3. 快速排序
   a. 快速排序(Quick Sort)也被称为划分排序或分区排序，它是目前所有的内部排序方法中速度最快的一种，快速排序是对起泡排序的一种改进。
   b. 快速排序的思想是：选取一个基准数（一般取第一个数），将比基准数小的数放到基准数的前面，比基准数大的数交换到基准数的后面。经历一趟排序之后基准数左面都是比它小的数，右面都是比它大的数。对左右两个区间重复之前的操作，直到每个区间只有一个元素为止。

#include <stdio.h>
void Print(int arr[], int len)
{
    for (int i = 0; i < len; ++i)
    {
        printf("%d ", arr[i]);
    }
}
void QuickSort(int arr[], int start, int end)
{
    //这里的i和j表示初始的start和end
    int i = start;
    int j = end;
    int temp = arr[start];
    if (start < end)
    {
        while (start < end)
        {
            //从右向左找比基准数小的元素
            while (start < end && arr[end] >= temp)
            {
                end--;
            }
            if (start < end)
            {
                arr[start] = arr[end];
                start++;
            }
            //从左向右找比基准数大的元素
            while (start < end && arr[start] <= temp)
            {
                start++;
            }
            if (start < end)
            {
                arr[end] = arr[start];
                end--;
            }
        }
        //把基准数放到start和end重合的位置
        arr[end] = temp;
        //下面两行代码使用了递归的思想
        //对左半部分快排
        QuickSort(arr, i, end - 1);//此处用初始的start即i
        //对右半部分进行快排
        QuickSort(arr, end + 1,j);//此处用初始的end即j
    }
}
int main(void)
{
    int arr[] = {1,9,7,2,4,3,6,5,0,8};
    int len = sizeof(arr) / sizeof(int);
    printf("排序之前：\n");
    Print(arr, len);
    QuickSort(arr, 0, len - 1);
    printf("\n");
    printf("排序之后：\n");
    Print(arr, len);
    return 0;
}

参考https://blog.csdn.net/weixin_42133358/article/details/107504760