1. 冒泡排序

算法思想：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对 每一对 相邻元素作同样的工作，从开始第一对到结尾的最后一对。

这样做完后，最后的元素会是最大的数。针对所有的元素重复以上的步骤，除了最后一个（不进行 和 不存在的 后下一个对比） 。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

#include <stdio.h>

// 长度只可以传入，不可在内部计算。
// 因为数组名会 退化为指针
void BubbleSort(int *arr, int len)
{
    int i, j, tmp;
    // N个长度,len-1为最大下标。
    // 只需和 [0, (len-1) -1]比较
    for (i = 0; i < len - 1; i++)
    {
        // 每回都把遍历到的 最大数值放到 当前的最后位置
        for (j = 0; j < len - 1 - i; j++)
        {
            // 正序排列
            if (arr[j] > arr[j + 1])
            {
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}

int main(int argc, char *argv[])
{
    int arr[] = {231, 312, 5, 4231, 2, 3};

    BubbleSort(arr, sizeof(arr) / sizeof(*arr));
    for (size_t i = 0; i < sizeof(arr) / sizeof(*arr); i++)
        printf("%d\t", arr[i]);
    putchar(10);
}

2. ** 快速排序 **

算法思想：
从数列中挑出一个元素，称为 “基准”（pivot）;

● 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。

在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

● 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

#include <stdio.h>

//快速排序函数，形参列表为数组，左指针位置，右指针位置，int *arr等价于int arr[]
void QkSort(int *arr, int left, int right)
{
    if (left > right) //左指针位置必须大于右指针位置:即两端下标
        return;

    //变量tmp为基准数，在此规定基准数为序列的第一个数，即左指针指向的数
    int tmp = arr[left];
    int i = left;  //左指针
    int j = right; //右指针

    //外循环，直到左指针和右指针相等时退出，表示根据当前基准数以完成当前序列排序
    while (i != j)
    {
        //内循环1，寻找到比基准数小的数时退出循环，此循环控制右指针
        while (arr[j] >= tmp && j > i)
            j--;

        //内循环2，寻找到比基准数大的数时退出循环，此循环控制左指针
        while (arr[i] <= tmp && j > i)
            i++;

        //经过以上两个内循环后，此时的左指针和右指针分别指向了
        //比基准数小 和 比基准数大的数
        //接下来要将这两个指针的数据进行交换
        if (j > i) //交换前判断右指针是否大于左指针
        {
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }
    } //外循环尾

    //执行完循环后，就找到了基准数的排序位置，将基准数tmp与i位置进行交换
    arr[left] = arr[i];
    arr[i] = tmp;

    /* 下面的程序为递归，可能存在多层递归调用 */

    //此时的数组分为了两部分，基准数左边都是小于基准数的，右边都是大于基准数的，
    //现在进行递归，对基准数左边的数进行排序，此时递归可能会有多层
    QkSort(arr, left, i - 1);
    
    //进行到这步时，基准数左边已经全部有序，而右边还未进行排序，
    //现在进行递归，对基准数右边的数据进行排序，此时递归可能有多层
    QkSort(arr, i + 1, right);
}

int main()
{
    int arr[] = {0, 4, 3, 5, 65, 2, 64, 68, 34, 94, 53, 74, 13};
    int len = sizeof(arr) / sizeof(int);

    printf("待排序数值：");
    for (int i = 0; i <= len - 1; i++)
        printf("%d ", arr[i]);
    printf("\n");

    QkSort(arr, 0, len - 1); //调用快速排序函数

    printf("排序后的数值：");
    for (int i = 0; i <= len - 1; i++)
        printf("%d ", arr[i]);
    printf("\n");
}

3. 选择排序

算法思想：

Ⅰ. 在 未排序序列中 找到最小（大）元素，存放到排序序列的 当前起始位置**
Ⅱ. 从剩余未排序元素中继续寻找最小（大）元素，然后放到 当前 已排序序列的末尾****
**Ⅲ. 以此类推，直到所有元素均排序完毕

#include <stdio.h>

// 交换两个变量
void swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 选择排序
void selection_sort(int arr[], int len)
{
    int i, j;
    for (i = 0; i < len - 1; i++)
    {
        int min = i;

        // 从i的下个位置开始到结尾，因为i被作为min下标
        for (j = i + 1; j < len; j++) //访问未排序的元素
            if (arr[j] < arr[min])    //找到目前最小值
                min = j;              //记录最小值

        swap(&arr[min], &arr[i]); //做交换
    }
}

int main(int argc, char *argv[])
{
    int arr[] = {231, 312, 5, 4231, 2, 3};

    selection_sort(arr, sizeof(arr) / sizeof(*arr));
    for (size_t i = 0; i < sizeof(arr) / sizeof(*arr); i++)
        printf("%d\t", arr[i]);
    putchar(10);
}