C语言-11

基本了解

/*
    学习内容：
        冒泡排序（最基本的排序方法）
        选择排序（冒泡的优化）
        插入排序（在合适的位置插入合适的数据）
*/

/*
    排序分类：
        1.内部排序
            待需要进行排序的数据全部存放到内存中，再进行排序 
        2.外部排序
            在排序过程中，需要对外存进行访问
            待排序的数据数量很大，内存无法全部容纳所有的数据 
*/

冒泡排序

/*
    冒泡排序：
    ---思路分析（以升序为例）
        在一排数据中，将第一个与第二个比较大小
        如果后面的数据比前面的小，就交换它们的位置（冒泡一次）
        然后比较第二个和第三个
        ...
        直到比较第 n-1 个数据和第 n 个
        每一次比较都将较大的一个数据向后移动
        所以第 n 个是最大的
        所以就排好了一个数据（冒泡一趟）
*/

# include <stdio.h>

int main()
{
    // 定义一个无序一维数组
    int arr[] = { 5, 7, 9, 1, 6, 2, 4, 3, 0, 8 };


    // 遍历，打印数组
    printf("数组，排序前：\n");
    for (int i = 0; i < 10; i++)
    {
        printf("%-3d", arr[i]);
    }


    // 冒泡排序（升序：由小到大）
    int temp;
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < 9 - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }


    // 展示排序后，数组当前的结果
    printf("数组，排序后：\n");
    for (int i = 0; i < 10; i++)
    {
        printf("%-3d", arr[i]);
    }

}

选择排序

/*
    选择排序：
    ---思路分析（以升序为例）
            选择排序可以看作是冒泡排序的优化
        不再多次交换值，而是选择当前趟数的最大(或最小值)，最后再交换
            在 n 个数里，先找到最大的数，并且记录下标，然后将这个数与第 n 个数交换
        如果第 n 个数是最大的，那就不需要交换，重复比较，直到所有的数据排好序
*/

# include <stdio.h>

int main()
{
    // 定义一个无序一维数组
    int arr[] = { 5, 7, 9, 1, 6, 2, 4, 3, 0, 8 };


    // 遍历，打印数组
    printf("\n 数组，排序前：\n");
    for (int i = 0; i < 10; i++)
    {
        printf("%-3d", arr[i]);
    }


    // 选择排序（升序：由小到大）---> 选择排序：选择一个你认为最大的数
    int temp;
    int maxIndex;
    for (int i = 9; i > 0; i--)
    {
        maxIndex = 0;    // 每次我都认为第一个最大，选择第一个，并记录下第一个的序号
        for (int j = 0; j <= i; j++)
        {
            if (arr[maxIndex] < arr[j])
            {
                maxIndex = j;
            }
        }

        if (maxIndex != i)
        {
            temp = arr[i];
            arr[i] = arr[maxIndex];
            arr[maxIndex] = temp;
        }

    }
    

    // 展示排序后，数组当前的结果
    printf("\n 数组，排序后：\n");
    for (int i = 0; i < 10; i++)
    {
        printf("%-3d", arr[i]);
    }

}

插入排序

/*
    插入排序：
    ---思路分析（以升序为例）
        以第一个数为基准，后面的所有数都向着第一个数的方向，插队前进（这种插队不能跳着插队，只能插完一个继续接着插，前提是满足条件才能插队）
        其本质原理：依靠数与数之间的“相对关系”，从而将其整体排好序！

            1.轮到第一个数发挥            第一个数无法插队，它只能站着不动，停止插队
            2.轮到第二个数发挥            它和前面的数比较大小，若满足条件，则插一个队，然后停止插队（即：最多能够插队1次）
            3.轮到第三个数发挥            和前面的数比较大小，若满足条件，则插一个队，再继续和前面的数比较大小，若满足条件，则再插一个队，然后停止插队（即：最多能够插队2次）
            4.轮到第四个数发挥            比较大小，若可以，插一个队，再继续比较大小，若可以，再插一个队......（即：最多能够插队3次）
            5.轮到第五个数发挥            ......（即：最多能够插队4次）
            6.轮到第六个数发挥            ......（即：最多能够插队5次）

*/

# include <stdio.h>

int main()
{
    // 定义一个无序一维数组
    int arr[] = { 7, 5, 9, 1, 6, 2, 4, 3, 0, 8 };


    // 遍历，打印数组
    printf("\n 数组，排序前：\n");
    for (int i = 0; i < 10; i++)
    {
        printf("%-3d", arr[i]);
    }


    // 插入排序（升序：由小到大） 
    int temp = 0;
    for (int i = 1; i < 10; i++)    // 轮到第 ？个数发挥
    {

        for (int j = i - 1; j >= 0; j--)    // 【比较、插队】，再【比较、插队】，再再【比较、插队】......
        {
            if (arr[j + 1] < arr[j])    // 满足插队条件
            {
                temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
            }
            else   // 不满足插队条件
            {
                break;        // 没有达到"最多能插队的次数"，就停止插队了，请马上自我了断，不要再进行无意义的比较，从而提高效率
            }
        }

    }


    // 展示排序后，数组当前的结果
    printf("\n 数组，排序后：\n");
    for (int i = 0; i < 10; i++)
    {
        printf("%-3d", arr[i]);
    }

    return 0;
}