五大排序算法（C语言版）

最新推荐文章于 2024-06-15 14:53:29 发布
最新推荐文章于 2024-06-15 14:53:29 发布
阅读量1.7k 收藏 45
点赞数 36
分类专栏： C/C++ 文章标签： 排序算法 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/djc3501558870/article/details/136592782
版权

计数排序

  1. 计数排序：是一个非基于比较的排序算法，该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时，快于任何比较排序算法。

  2. 排序思路

    1. 找出待排序数组最大值，确定排序数组的索引值
    2. 定义一个索引最大值为待排序数组最大值的数组
    3. 遍历待排序数组，将待排序数组中每个数字出现的次数存储在排序数组中
    4. 整理排序数组中的数字，如果排序数组的值不为零，输出对应的下标值
    5. 最后将索引值输出即为排序结果

  3. 解释

    在这里插入图片描述

  4. 示例

    #include <stdio.h>

void CountingSort(int length,int OriginalArray[length]);
void PrintArray(int length,int OriginalArray[length]);

int main()
{
    //创建待排序数组
    int length;
    printf("请输入待排序数组长度：");
    scanf("%d",&length);
    int OriginalArray[length];

    //初始化待排序数组
    printf("请输入待排序数组元素：");
    for(int i = 0;i < length;i++)
    {
        scanf("%d",&OriginalArray[i]);
    }

    //调用排序函数对待排序数组进行排序
    CountingSort(length,OriginalArray);

    //打印结果
    PrintArray(length,OriginalArray);

    return 0;
}

//排序函数
void CountingSort(int length,int OriginalArray[length])
{
    //寻找待排序数组最大值
    int max = OriginalArray[0];
    for(int i =1;i < length;i++)
    {
        if(OriginalArray[i] > max)
        {
            max = OriginalArray[i];
        }
    }

    //创建排序数组
    int SortArray[max + 1];

    //初始化排序数组
    for(int i = 0;i <= max;i++)
    {
        SortArray[i] = 0;
    }

    //统计待排序数组每个数字出现的次数
    for(int i = 0;i < length;i++)
    {
        SortArray[OriginalArray[i]]++;
    }

    //整理排序数组
    int index = 0;
    int AuxiliaryArray[length];
    for(int i = 0;i <= max;i++)
    {
        while(SortArray[i] > 0)
        {
            AuxiliaryArray[index] = i;
            index++;
            SortArray[i]--;
        }
    }

    //将排序结果返回待排序数组
    for(int i = 0;i < length;i++)
    {
        OriginalArray[i] = AuxiliaryArray[i];
    }
}

//打印结果
void PrintArray(int length,int OriginalArray[length])
{
    for(int i = 0;i < length;i++)
    {
        printf("%d ",OriginalArray[i]);
    }
}

    在这里插入图片描述

  5. 练习

    输入90到100以内的5个数，优化计数排序，避免资源浪费

    #include <stdio.h>

void CountingSort(int length,int OriginalArray[length]);
void PrintSort(int length,int OriginalSort[length]);

int main()
{
    //定义待排序数组
    int length;
    printf("请输入待排序数组长度:");
    scanf("%d",&length);
    int OriginalArray[length];

    //初始化待排序数组
    printf("请输入待排序数组元素：");
    for(int i = 0;i < length;i++)
    {
        scanf("%d",&OriginalArray[i]);
    }

    //调用函数
    CountingSort(length,OriginalArray);

    //打印结果
    PrintSort(length,OriginalArray);

    return 0;
}

//排序算法
void CountingSort(int length,int OriginalArray[length])
{
    //寻找待排序数组最大最小值
    int max = OriginalArray[0];
    int min = OriginalArray[0];
    for(int i = 1;i < length;i++)
    {
        if(OriginalArray[i] > max)
        {
            max = OriginalArray[i];
        }
        if(OriginalArray[i] < min)
        {
            min = OriginalArray[i];
        }
    }

    //定义计数数组
    int size = max -  min + 1;
    //int maximum = max - min;
    int SortArray[size];

    //初始化计数数组
    for(int i = 0;i < size;i++)
    {
        SortArray[i] = 0;
    }

    //统计待排序数组每个元素出现次数
    for(int i = 0;i < length;i++)
    {
        SortArray[OriginalArray[i] - min]++;
    }

    //整理计数数组
    int index = 0;
    int AuxiliaryArray[length];
    for(int i = 0;i < size;i++)
    {
        while(SortArray[i] > 0)
        {
            AuxiliaryArray[index] = i + min;
            index++;
            SortArray[i]--;
        }
    }

    //将排序结果返回待排序数组
    for(int i = 0;i < length;i++)
    {
        OriginalArray[i] = AuxiliaryArray[i];
    }
}

//打印结果
void PrintSort(int length,int OriginalSort[length])
{
    for(int i = 0;i < length;i++)
    {
        printf("%d ",OriginalSort[i]);
    }
}

选择排序

  1. 原理：先寻找待排序数组中的最小值，放在第一位，然后寻找剩下的数字中的最小值，放在第二位，以此类推，直到排序完成。

  2. 排序思路

    1. 利用第0个元素和后面的元素依次进行对比
    2. 判断第0个元素是否大于当前被比较元素, 一旦小于就交换位置
    3. 第0个元素和后续所有元素比较完成后, 第0个元素就是最小值
    4. 排除第0个元素, 用第1个元素重复1~3操作, 比较完成后第1个元素就是倒数第二小的值
    5. 以此类推, 直到当前元素没有可比较的元素, 排序完成

  3. 解释

    在这里插入图片描述

  4. 示例

    #include <stdio.h>

void SelectSort(int length,int OriginalArray[length]);
void PrintArray(int length,int OriginalArray[length]);

int main()
{
    //定义待排序数组
    int length;
    printf("请输入待排序数组长度：");
    scanf("%d",&length);
    int OriginalArray[length];

    //初始化待排序数组
    printf("请输入待排序数组元素：");
    for(int i = 0;i < length;i++)
    {
        scanf("%d",&OriginalArray[i]);
    }

    //调用排序函数
    SelectSort(length,OriginalArray);

    //打印结果
    PrintArray(length,OriginalArray);

    return 0;
}

//排序函数
void SelectSort(int length,int OriginalArray[length])
{
    for(int i = 0;i < length;i++)
    {
        for(int j = i;j < length - 1;j++)
        //j < length - 1的原因：最后一位数不用做比较，如果继续拿着最后一位数与后面的术进行比较，一来是后面没有数字，二来是会造成数组越界
        {
            if(OriginalArray[i] > OriginalArray[j + 1])
            {
                int temp = OriginalArray[j + 1];
                OriginalArray[j + 1] = OriginalArray[i];
                OriginalArray[i] = temp;
            }
        }
    }
}

//打印结果
void PrintArray(int length,int OriginalArray[length])
{
    for(int i = 0;i < length;i++)
    {
        printf("%d ",OriginalArray[i]);
    }
}

    在这里插入图片描述

冒泡排序

  1. 冒泡排序：是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

  2. 冒泡排序

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

    2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

    3. 针对所有的元素重复以上的步骤，除了最后一个。

    4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

  3. 解释

在这里插入图片描述

  1. 示例

    #include <stdio.h>

void BubbleSort(int length,int OriginalArray[length]);
void PrintArray(int length,int OriginalArray[length]);

int main()
{
    //创建待排序数组
    int length;
    printf("请输入待排序数组长度：");
    scanf("%d",&length);
    int OriginalArray[length];

    //初始化待排序数组
    printf("请输入待排序数组元素：");
    for(int i = 0; i < length;i++)
    {
        scanf("%d",&OriginalArray[i]);
    }

    //调用排序函数
    BubbleSort(length,OriginalArray);

    //打印结果
    PrintArray(length,OriginalArray);

    return 0;
}

//排序函数
void BubbleSort(int length,int OriginalArray[length])
{
    for(int i = 0;i < length;i++)
    {
        for(int j = 0;j < length - 1 -i;j++)
        {
            if(OriginalArray[j] > OriginalArray[j + 1])
            {
                int temp = OriginalArray[j];
                OriginalArray[j] = OriginalArray[j + 1];
                OriginalArray[j + 1] = temp;
            }
            
        }    
    }
}

//打印结果
void PrintArray(int length,int OriginalArray[length])
{
    for(int i = 0;i < length;i++)
    {
        printf("%d ",OriginalArray[i]);
    }
}

  2. 计数排序与冒泡排序的区别

    乍一看，两种排序算法的代码貌似都一样，但是从原理上我们也知道，两者不一样，区别就在于选择排序是找最小值，而冒泡排序是比较相邻两数字的大小。

    在这里插入图片描述

插入排序

  1. 插入排序：是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

  2. 算法步骤

    1. 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
    2. 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

  3. 解释

    在这里插入图片描述

  4. 示例

    #include <stdio.h>

void InsertionSort(int length,int OriginalArray[length]);
void PrintReasult(int length,int OriginalArray[length]);

int main()
{
    //创建待排序数组
    int length;
    printf("请输入待排序数组长度：");
    scanf("%d",&length);
    int OriginalArray[length];

    //初始化待排序数组
    printf("请输入待排序数组元素：");
    for(int i = 0;i < length;i++)
    {
        scanf("%d",&OriginalArray[i]);
    }

    //调用排序函数
    InsertionSort(length,OriginalArray);

    //打印结果
    PrintReasult(length,OriginalArray);

    return 0;
}

//排序函数
void InsertionSort(int length,int OriginalArray[length])
{
    int key;
    for(int i = 1;i < length;i++)
    {
        key = OriginalArray[i];
        int j = i - 1;
        while((j >= 0) && (OriginalArray[j] > key))
        {
            OriginalArray[j + 1] = OriginalArray[j];
            j--;
        }
        OriginalArray[j + 1] = key;
    }
}

//打印结果
void PrintReasult(int length,int OriginalArray[length])
{
    for(int i = 0;i < length;i++)
    {
        printf("%d ",OriginalArray[i]);
    }
}

希尔排序

  1. 希尔排序:也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

  2. 希尔排序是基于插入排序的以下两点性质而提出改进方法的：

    1. 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
    2. 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。

  3. 基本思想

    先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。

  4. 算法步骤

    1. 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；

    2. 按增量序列个数 k，对序列进行 k 趟排序；

    3. 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

  5. 解释

    在这里插入图片描述

  6. 示例

    #include <stdio.h>

void ShellSort(int length,int OriginalArray[length]);
void PrintReasult(int length,int OriginalArray[length]);

int main()
{
    //创建待排序数组
    int length;
    printf("请输入待排序数组的长度：");
    scanf("%d",&length);
    int OrigianlArray[length];

    //初始化待排序数组
    printf("请输入待排序数组元素：");
    for(int i = 0;i < length;i++)
    {
        scanf("%d",&OrigianlArray[i]);
    }

    //调用排序函数
    ShellSort(length,OrigianlArray);

    //打印结果
    PrintReasult(length,OrigianlArray);

    return 0;
}

//排序函数
void ShellSort(int length,int OriginalArray[length])
{
    int temp;
    for(int gap = length >> 1;gap > 0;gap >>= 1)
    {
        for(int i = gap;i < length;i++)
        {
            temp = OriginalArray[i];
            int j;
            for(j = i - gap;j >= 0 && OriginalArray[j] > temp;j -= gap)
            {
                OriginalArray[j + gap] = OriginalArray[j];
            }
            OriginalArray[j + gap] = temp;
        }
    }
}

//打印结果
void PrintReasult(int length,int OriginalArray[length])
{
    for(int i = 0;i < length;i++)
    {
        printf("%d ",OriginalArray[i]);
    }
}
啊这8675
关注
  • 36
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
c语言大小排序算法,七种常见的数组排序算法整理(C语言版本)
weixin_39840635的博客
05-19 3249
～～～C语言版本～～～冒泡排序选择排序直接插入排序二分插入排序希尔排序快速排序堆排序#define EXCHANGE(num1, num2) { num1 = num1 ^ num2;\num2 = num1 ^ num2;\num1 = num1 ^ num2;}排序算法是否稳定:相同元素的相对在排序前后是否会发生改变，如果会，就是不稳定的，否则就是稳定的。一.冒泡排序冒泡排序原理很容易理解，...
C语言实现的冒泡排序（bubbleSort）算法示例
01-03
冒泡排序是一种简单但效率较低的排序算法，它的基本思想是通过相邻元素之间的比较和交换，将较大（或较小）的元素逐渐“浮”到数组的一端。希望这个示例能帮助你理解如何在C语言中实现冒泡排序算法！
C语言的5种简单排序算法
热门推荐
Finecsr的博客
04-27 5万+
基本概要： 本文主要介绍五种简单常用的排序算法：冒泡排序，快速排序，插入排序，选择排序，希尔排序，包括它们的基本思想和代码实现。值得一说的是：插入排序，冒泡排序，选择排序平均情况下的时间复杂度为，因此在排序数据较少的情况下较好；而希尔排序和快速排序的平均时间复杂度为，因此在排序数据较多的情况下较好，但是对于快速排序而言，数据基本有序时反而不好，接下来会详细阐述。 1.冒泡排序（Bubble Sort） 基本思想： 冒泡排序是一个非常好理解的排序，顾名思义——冒泡，此时将要排序的数据从上至下排列，从最
八大排序算法(C语言)
weixin_49312527的博客
02-20 2054
目录 一.插入排序 1.1直接插入排序 1.2希尔排序 二.选择排序 2.1选择排序 2.2堆排序 三.交换排序 3.1冒泡排序 3.2快速排序 四.归并排序 4.1归并排序 五.非比较排序 5.1计数排序 一.插入排序 基本思想:(默认升序)从数组中的第二个元素开始,先使用一个变量保存这个元素的下标,开然后始跟前一个比较,如果比他小则交换位置继续跟前一个比较,直到找到一个位置比它的前一个元素大则停止(或走到数组开头也停止),然后保存的下标后移继续之前的操作,直到数组末
【排序算法】冒泡排序（C语言）
weixin_52811588的博客
07-10 5万+
冒泡排序法是最简单的排序算法之一，这里详述了冒泡排序法的排序原理，以及C语言的代码实现，还有模拟库函数qsort的实现
基数（桶）排序算法详解之C语言版
sunnyoldboy博客
09-25 2839
基数排序算法又称桶排序，是一种原理简单实现相对麻烦一点的算法。基数排序属于稳定排序法，适用于数值比较大的数据之间的排序。 常见的内部排序算法中都使用到了元素之间的比较大小，而基数排序算法不涉及元素之间的比较，而是根据基数将数据存放到相应的“桶”里，经过多趟这样的存放过程，也就是一个渐进排序过程，就可以实现对一组散乱数据进行排序。总趟数是数组中位数最多的那个元素的位数。其实读到这里，大家是不是有一种很熟悉的感觉，没错，这跟创建Hash（散列）表的原理类似。
九大排序算法（c语言版）
m0_75233418的博客
02-16 1696
过年这几天晚上在家码代码学了一点。代码中排序的数字均由rand()函数随机生成。
【C语言】——十大排序算法
weixin_73807021的博客
03-17 3710
学了算法之后相信大家还需要整理一份关于算法的笔记，希望这篇文章能给大家带来一些启发和帮助。学习算法就是学习解决问题思想，在面对一个问题要利用算法的思维来思考会对解题有很大的帮助。本小白的此次分享就到这里结束啦，欢迎各位佬多多指正。
c语言排序算法（使用链表）
Ethereal_tl的博客
12-22 3009
直接插入排序、折半插入排序、希尔排序、气泡排序(又称冒泡排序,直接交换排序)、快速排序、选择排序
五大排序算法
m0_50708613的博客
12-18 2964
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、概念 二、十大算法介绍 1.冒泡算法 2.插入算法 3.希尔算法 4.选择算法 5.快速算法 6.计数算法 7.基数算法 8.归并排序 9.堆排序 10.桶排序 总结 前言 排序算法（Sorting algorithm）是一种能将一串资料依照特定排序方式进行排列的一种算法 提示：以下是本篇文章正文内容，下面案例可供参考 一、概念 示例：pandas
冒泡排序算法之C语言实现
Stayhungry,Stayfoolish.
07-23 6652
冒泡排序是一种简单的排序算法，它也是一种稳定排序算法。其实现原理是重复扫描待排序序列，并比较每一对相邻的元素，当该对元素顺序不正确时进行交换。一直重复这个过程，直到没有任何两个相邻元素可以交换，就表明完成了排序。...
常见经典排序算法（C语言）1希尔排序 二分插入法 直接插入法 带哨兵的直接排序法 冒泡排序 选择排序 快速排序 堆排序.docx
05-07
常见经典排序算法（C语言） 在计算机科学中，排序算法是一种基本且重要的算法。它的主要作用是将无序的数据序列变换为有序的数据序列，以便于后续的数据处理和分析。常见的经典排序算法有希尔排序、二分插入法、...
c语言分治法求众数重数-五大常见算法策略之——递归与分治策略，算法数据结构
04-07
分治策略的其他经典应用包括排序算法，如快速排序和归并排序。快速排序通过选取一个“基准”元素，将数组分为两部分，一部分的所有元素都小于基准，另一部分的所有元素都大于基准，然后递归地对这两部分进行快速排序...
数据结构C语言版讲义.doc
11-30
数据结构C语言版讲义 本讲义旨在介绍数据结构的基本概念、逻辑结构、存储结构、抽象数据类型、算法描述及分析等知识点。 第一章 绪论 1.什么是数据结构？ 数据结构是研究操作对象及其之间的关系和操作，忽略数据...
数据结构C语言版复习攻略.docx
12-18
数据结构C语言版复习攻略 数据结构的基本概念 数据元素是数据的基本单位，数据项是数据不可分割的最小单位。数据结构是指对数据元素的组织和存储方式。数据结构可以分为四种基本结构：集合、线性结构、树形结构和...
Java实现快速排序
liuhaikang的博客
06-11 343
方法是快速排序的核心，它选择一个基准值（在这个例子中是最右侧的元素），然后重新排列数组，使得所有小于基准值的元素都出现在基准值的左侧，所有大于基准值的元素都出现在基准值的右侧。快速排序（Quick Sort）是一种高效的排序算法，它采用分治的思想。方法，它是快速排序的主要方法。该方法接受一个数组和左、右索引作为参数，并使用递归对数组进行排序。方法中，我们创建了一个测试数组并调用。方法用于交换数组中的两个元素。这个代码首先定义了一个。
排序算法、堆排序、大顶堆、小顶堆、手写快排-215. 数组中的第K个最大元素、2336. 无限集中的最小数字
最新发布
FLJS_T的博客
06-15 198
题目所述为找到第K个最大元素，首先想到使用Arrays.sort(nums);return nums[nums.length - k]即可解决，此时很好，可以回家等通知了。第K个最大元素，如果创建一个小顶堆，堆顶元素为最小，并维护堆中元素个数为K，当nums数组遍历结束后，堆顶元素即为返回的元素。快排本质上就是对Arrays.sort(nums)的一种优化手段，具体可以网上查找资源，贴出自己编写的快。排序算法、堆排序、大顶堆、小顶堆、手写快排-215. 数组中的第K个最大元素、2336. 无限集中的最小数字
Java的c/s架构如何同时访问多个数据源
codemami的博客
06-11 1152
在Java的客户端/服务器（C/S）架构中，当服务器需要同时访问多个数据源时，通常是在服务器端进行配置和实现的。可以通过继承这个类来自定义多数据源的连接。在Java的C/S（客户端/服务器）架构中，实现同时访问多个数据源通常涉及后端服务器的设计和实现。接下来，你需要实现一个动态数据源路由的功能，这通常是通过继承AbstractRoutingDataSource类来实现的。配置数据源：为每个数据源创建DataSource对象，并配置相应的数据库连接信息，如驱动类名、URL、用户名和密码等。
力扣2187.完成旅途的最少时间
Pisasama的博客
06-12 417
二分答案。
冒泡排序五个数比大小c语言
08-29
冒泡排序是一种简单但有效的排序算法。对于五个数比大小，可以使用冒泡排序对它们进行排序。 首先，我们可以声明一...以上代码示例通过冒泡排序算法对数组进行排序，输出结果为：1 2 3 4 5，即按从小到大排序的结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值