精华内容
下载资源
问答
  • 本文实例讲述了C语言排序算法之冒泡排序实现方法。分享给大家供大家参考,具体如下: 冒泡排序和改进的冒泡排序 /*------------------------------------------------------------------------------------------- ...
  • 主要为大家详细介绍了C语言排序算法之插入排序,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • c语言排序方法有:1、简单选择排序,基于O(n2)时间复杂度的排序算法;2、冒泡排序;3、简单插入排序;4、希尔排序;5、归并排序,基于归并操作的一种排序算法;6、快速排序,属于分治法的一...

    c语言排序方法有:1、简单选择排序,基于O(n2)时间复杂度的排序算法;2、冒泡排序;3、简单插入排序;4、希尔排序;5、归并排序,基于归并操作的一种排序算法;6、快速排序,属于分治法的一种;7、堆排序等。

    1.选择排序-简单选择排序
    选择排序是最简单的一种基于O(n2)时间复杂度的排序算法,基本思想是从i=0位置开始到i=n-1每次通过内循环找出i位置到n-1位置的最小(大)值。

    2.冒泡排序
    冒泡排序在一组需要排序的数组中,对两两数据顺序与要求顺序相反时,交换数据,使大的数据往后移,每趟排序将最大的数放在最后的位置上。

    3.插入排序-简单插入排序
    插入排序是将一个记录插入到已经有序的序列中,得到一个新的元素加一的有序序列,实现上即将第一个元素看成一个有序的序列,从第二个元素开始逐个插入得到一个完整的有序序列。

    4.插入排序-希尔排序
    希尔排序的基本思想是先取一个小于n的整数d1作为第一个增量,把全部元素分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序;然后,取第二个增量d2 < d1重复上述的分组和排序,直至所取的增量 =1( < …< d2 < d1),即所有记录放在同一组中进行直接插入排序为止,希尔排序主要是根据插入排序的一下两种性质对插入排序进行改进:

    1)插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率。

    2)但插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位

    5.归并排序
    归并排序是基于归并操作的一种排序算法,归并操作的原理就是将一组有序的子序列合并成一个完整的有序序列,即首先需要把一个序列分成多个有序的子序列,通过分解到每个子序列只有一个元素时,每个子序列都是有序的,在通过归并各个子序列得到一个完整的序列。

    6.快速排序
    快速排序跟归并排序类似属于分治法的一种,基本思想是通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

    7.堆排序
    堆其实一种树形结构,以二叉堆为例,是一颗完全二叉树(即除最后一层外每个节点都有两个子节点,且非满的二叉树叶节点都在最后一层的左边位置),二叉树满足每个节点都大于等于他的子节点(大顶堆)或者每个节点都小于等于他的子节点(小顶堆),根据堆的定义可以得到堆满足顶点一定是整个序列的最大值(大顶堆)或者最小值(小顶堆)。

    声明:

    本文于网络整理,版权归原作者所有,如来源信息有误或侵犯权益,请联系我们删除或授权事宜。

    展开全文
  • 在STM8S003单片机上实现数组排序,用3种冒泡排序法对数组进行排序,并通过串口打印排序过程。
  • C语言排序总结

    2015-05-14 11:05:17
    是对C语言排序的各种总结,包含冒泡,选择,快速,希尔等排序方式,言简意赅
  • C语言排序问题

    千次阅读 多人点赞 2018-10-12 00:22:02
    C语言常见的排序方法有:冒泡排序、选择排序、快速排序等等。 这里一一进行列举: 1.冒泡排序:在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往...

    C语言常见的排序方法有:冒泡排序、选择排序、快速排序等等。
    这里一一进行列举:
    1.冒泡排序:在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。
    ps:一列数组a[] = {85, 73, 62, 95, 87, 25, 12}; 采用冒泡排序法从小到大排序。
    #include <stdio.h>
    int main()
    {
    int a[] = {85, 73, 62, 95, 87, 25, 12};
    int i, j;
    int t;
    for(i = 0; i < 7 - 1; i++){
    for(j = 0; j < 6 - i; j++){
    if(a[j] > a[j + 1]){
    t = a[j];
    a[j] = a[j + 1];
    a[j + 1] = t;
    }
    }
    }
    for(i = 0; i < 7; i++){
    printf("%d\n", a[i]);
    }
    }
    解析:
    假设一维数组有N个数据,外层循环共循环(N-1)次;内层循环需要循环(N-1-i)次,i为此时外层循环的次数,当前边的数据小于后边的数据时,进行数据交换。

    时间复杂度分析:
    其外层循环执行 N - 1次。内层循环最多的时候执行N-1次,最少的时候执行1次,平均执行 (N+1-1)/2次。
    所以循环体内的比较交换约执行 (N - 1)*N / 2 =(N^2-1)/2次。按照计算复杂度的原则,去掉常数,去掉最高项系数,其复杂度为O(N ^ 2)。

    2.选择排序:选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理选择一个值array[0]作为标杆,然后循环找到除这个值外最小的值(查找小于标杆的最小值),交换这两个值,这时最小值就被放到了array[0]上,然后再将array[1]作为标杆,从剩下未排序的值中找到最小值,并交换这两个值。选择排序是不稳定的排序方法。
    #include <stdio.h>
    void selet_sort(int p, int n)
    {
    int i, j, tmp;
    for(i=0;i<n-1;i++)
    {
    int min = i;
    for(j=i+1;j<n;j++)
    {
    if(
    (p+j)< *(p+min) )
    min=j;
    }
    if(i!=j)
    {
    tmp=p[i];
    p[i]=p[min];
    p[min]=tmp;
    }
    }
    }
    int main()
    {
    int a[5]={3,5,1,2,4}, i;
    selet_sort(a,5);
    for(i=0;i<5;i++)
    {
    printf("%d\n", *(a+i));
    }
    }
    时间复杂度分析:O(N^2),但与冒泡排序相比减少了数组交换的次数。

    展开全文
  • 本文给大家分享两种常用的C语言排序算法,代码非常简单,感兴趣的朋友可以参考下
  • 常见C语言排序函数

    千次阅读 2019-11-02 20:41:07
    直接插入排序 //直接插入排序 void InsertSort(int R[], int n) { int i, j; int tmp; for (i = 1; i < n; i++) { if (R[i] < R[i] - 1) { tmp = R[i]; j = i ...

    直接插入排序

    //直接插入排序
    void InsertSort(int R[], int n)
    {
        int i, j;
        int tmp;
        for (i = 1; i < n; i++)
        {
            if (R[i] < R[i] - 1)
            {
                tmp = R[i];
                j = i - 1;
                do {
                    R[j + 1] = R[j];
                    j--;
                } while (j >= 0 && R[j] > tmp);
                R[j + 1] = tmp;
            }
        }
    }
    
    

    折半插入排序

    //折半插入排序
    void BinInsertSort(int R[], int n)
    {
        int i, j, low, high, mid;
        int tmp;
        for (i = 1; i < n; i++)
        {
            if (R[i] < R[i - 1])
            {
                tmp = R[i];
                low = 0; high = i - 1;
                while (low <= high)
                {
                    mid = (low + high) / 2;
                    if (tmp < R[mid])
                        high = mid - 1;
                    else
                        low = mid + 1;
                }
                for (j = i - 1; j >= high + 1; j--)
                    R[j + 1] = R[j];
                R[high + 1] = tmp;  //重点
            }
        }
    }
    
    

    希尔排序

    //希尔排序
    void ShellSort(int R[], int n)
    {
        int i, j, d;
        int tmp;
        d = n / 2;
        while (d > 0)
        {
            for (i = d; i < n; i++)  //对所有组采用直接插入排序
            {
                tmp = R[i];
                j = i - d;
                while (j >= 0 && R[j] > tmp)
                {
                    R[j + d] = R[j];
                    j -= d;
                }
                R[j + d] = tmp;
            }
            d = d / 2;
        }
    }
    
    

    快速排序

    //快速排序
    void QuickSort(int R[], int s, int t)
    {
        int i;
        if (s < t)
        {
            i = partition(R, s, t);
            QuickSort(R, s, i - 1);
            QuickSort(R, i + 1, t);
        }
    }
    int partition(int R[], int s, int t)
    {
        int i = s, j = t;
        int tmp = R[i];
        while (i < j)
        {
            while (j > i&&R[j] > tmp)
                j--;
            R[i] = R[j];
            while (i < j&&R[i] < tmp)
                i++;
            R[j] = R[i];
        }
        R[i] = tmp;
        return i;
    }
    
    

    简单选择排序

    //简单选择排序
    void SelectSort(int R[], int n)
    {
        int i, j, min, tmp;
        for (i = 0; i < n - 1; i++)
        {
            min = j;
            for (j = i + 1; j < n; j++)
            {
                if (R[j] < R[min])
                    min = j;
            }
            if (min != i)
            {
                tmp = R[min];
                R[min] = R[i];
                R[i] = tmp;
            }
        }
    }
    
    
    展开全文
  • C语言排序综合练习

    2012-07-06 13:58:24
    功能介绍: 该程序是实现整数排序的程序,通过随机函数产生20000以上的整数,分别用(1)直接插入排序(2)冒泡排序(3)快速排序(4)直接选择排序(5)堆排序(6)希尔排序,六种方法来排序
  • C语言 排序

    2014-09-19 13:47:18
    使用C语言给任意的4个整数由小到大或由大到小的排序
  • C语言几种排序代码

    2018-07-07 16:05:19
    包括有十种排序方法,有堆排序,归并排序,基排序,简单选择排序,快速排序,冒泡排序等等
  • C语言排序(冒泡排序、选择排序、插入排序和快速排序)C语言排序什么是排序?1.冒泡排序基本思想主要思路:动态示例demo2.选择排序基本思想主要思路动态示例demo3.插入排序基本思想主要思路动态示例demo4.快速排序...

    C语言排序

    什么是排序?

    就是将无序的变成有序的

    1.冒泡排序

    基本思想

    在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。每一趟排序后的效果都是讲没有沉下去的元素给沉下去。

    主要思路:

    1.比较相邻的元素。如果第一个比第二个大,就交换它们两个。
    2.对每一个相邻元素做同样的工作,从开始第一对到结尾的每一对。在这一 点,最后的元素应该会是最大的数。
    3.针对多有的元素重复以上的步骤,除了最后一个。
    持续每次对越来越少的元素重复上面的步骤,知道没有任何一对数字需要比较。

    demo

    #include <stdio.h>
    
    //冒泡排序
    void BubbleSort(int arry[],int len)
    {
            int i;
            int j;
            int temp;
            for(i=0;i<len-1;i++)//比较次数
            {
                    for(j=0;j<len-1-i;j++)//比较过程
                    {
                            if(arry[j]>arry[j+1]) //比较大小
                            {
                                    temp=arry[j];
                                    arry[j]=arry[j+1];
                                    arry[j+1]=temp;
    
                            }
                    }
    
            }
    
    }
    //输出
    void print(int arry[],int len)
    {
            int i;
            for(i=0;i<len;i++)
            {
                    printf("%d ",arry[i]);
            }
    }
    int main()
    {
    
            int arry[10]={9,3,56,44,77,88,54,79,52,111};
    
            BubbleSort(arry,10);
            print(arry,10);
            printf("\n");
    
            return 0;
    }
    

    在这里插入图片描述

    2.选择排序

    基本思想

    选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。

    主要思路

    每一次从无序组的数据元素中选出最小的一个元素,存放在无序组的起始位置,无需组的元素减少,有序组的元素增加,直到全部待排序的数据元素排完。

    demo

    #include <stdio.h>
    
    //选择排序
    void selectSort(int arry[], int len)
    {       int i;
            int j;
            for ( i = 0; i < len-1; i++)
            {
                    int min = i;//假设第一个元素是最小的
                    for (j = i + 1; j < len; j++)
                    {
                            if (arry[j] < arry[min])
                            {
                                    min = j;//保存最小元素的下标
                            }
                    }
                    //交换
                    int temp = arry[min];
                    arry[min] = arry[i];
                    arry[i] = temp;
            }
    }
    //输出
    void print(int arry[], int len)
    {
            for (int i = 0; i < len; i++)
            {
                    printf("%d ", arry[i]);
            }
    }
    int main()
    {
            int arry[10]={15,36,26,27,24,46,44,29,52,48};
            selectSort(arry,10);
            print(arry,10);
    
    
            printf("\n");
            return 0;
    }
    
    

    在这里插入图片描述

    3.插入排序

    基本思想

    将待排序的无序数列看成是一个仅含有一个元素的有序数列和一个无序数列,将无序数列中的元素逐次插入到有序数列中,从而获得最终的有序数列。

    主要思路

    插入排序是最简单常用的方法,将数组分为两部分,排好序的数列,以及未排序的数列,将未排序的数列中的元素 与排好序的数列进行比较,然后将该元素插入到已排序列的合适位置中。

    demo

    #include <stdio.h>
    
    //插入排序
    void insertSort(int arry[], int len)
    {
            int i;
            int temp;//保存要插入的元素
            int j;//从当前要要比较插入的元素的前面一个开始
            for ( i = 1; i < len; i++)//第一个元素视为有序,把后面的元素一个一个的插入到前面
            {
                    temp = arry[i];
                    j = i - 1;
                    while (j >= 0&&arry[j]>temp)
                    {
                            arry[j + 1] = arry[j];//前面的元素往后面移动
                            j--;
                    }
                    arry[j + 1] = temp;//把要插入的元素,插入进对应的位置
            }
    }
    //输出
    void print(int arry[], int len)
    {
            for (int i = 0; i < len; i++)
            {
                    printf("%d ", arry[i]);
            }
    }
    int main()
    {
            int arry[10]={3,44,38,5,47,15,36,26,27,2};
            insertSort(arry,10);
            print(arry,10);
    
    
            printf("\n");
            return 0;
    }
    
    

    在这里插入图片描述

    4.快速排序

    基本思想

    快速排序算法的基本思想为分治思想。
    先从数列中取出一个数作轴值(基准数)pivot;
    根据基准数将数列进行分区,小于基准数的放左边,大于基准数的放右边;
    重复分区操作,知道各区间只有一个数为止。

    主要思路

    快速排序是找出一个元素(理论上可以随便找一个)作为基准,然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的值都不小于基准值,如此作为基准的元素调整到排序后的正确位置。递归快速排序,将其他n - 1 个元素也调整到排序后的正确位置。最后每个元素都是在排序后的正确位置,排序完成。所以快速排序算法的核心算法是分区操作,及如何调整基准的位置以及调整返回基准的最终位置以便分治递归。

    demo

    #include <stdio.h>
    
    //快速排序
    void quickSort(int arry[], int low, int high)
    {
            if (low > high)
            {
                    return;
            }
            int i = low, j = high, temp = arry[i];//获取左右和基准数
            while (i < j)
            {
                    while (temp < arry[j] && i < j)
                    {
                            j--;
                    }
                    if (i < j)
                      {
                            arry[i++] = arry[j];
                      }
                    while (temp>arry[i] && i < j)
                        {
    
                            i++;
                         }
                    if (i < j)
                        {
                            arry[j--] = arry[i];
                        }
            }
            arry[i] = temp;
    
            quickSort(arry, low, i - 1);//左边
            quickSort(arry, i + 1, high);//右边
    }
    //输出
    void print(int arry[], int len)
    {
            for (int i = 0; i < len; i++)
            {
                    printf("%d ", arry[i]);
            }
    }
    int main()
    {
    
            int arry[15]={7,44,38,99,47,15,36,26,27,2,46,43,19,50,48};
            quickSort(arry,0,14);
            print(arry,15);
    
            printf("\n");
            return 0}        
    

    在这里插入图片描述

    展开全文
  • c语言排序算法,其中包含插入排序,起泡排序,快速排序,选择排序
  • 收集整理了C语言中常用的经典排序方法(冒泡排序、选择排序、插入排序、希尔排序、快速排序、堆排序 )及动图演示 。
  • c语言排序算法(一)

    万次阅读 多人点赞 2018-05-27 12:29:59
    本篇文章用C语言为大家介绍排序算法之一冒泡排序的具体实现。 冒泡排序:它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也...
  • C语言排序算法.pdf

    2019-12-24 14:55:15
    C语言排序算法
  • 首先来看看选择排序法的定义 核心思想就是先在所有数据中选出一个最大或者最小的数放在第一位,然后再剩下的数据继续选最大或者最小的数放在第二位,依次进行下去直到结束。 下来直接看C代码的实现 #define ...
  • c语言常用的冒泡、简单选择、直接插入、快速排序函数代码
  • C语言排序函数qsort( )

    千次阅读 多人点赞 2017-10-06 09:12:53
    关于c语言排序的问题,以前我都是用冒泡排序或者快速排序,知道这几天,在杭电上面打ACM的时候,才发现又一种排序的函数,就是qsort();qsort()括号里面有4个参数 第一个参数是将要排序的数组名array; 第二个...
  • (c语言排序算法)sort.c

    2020-12-24 11:04:29
    排序算法:直接插入、折半插入排序、希尔排序、冒泡、快排、选择排序、堆排序、归并排序算法c语言实现,带有简要的注释(并非详解)
  • 常用C语言排序算法解析.pdf
  • C语言排序算法大全排序[收集].pdf
  • C语言 排序源码

    2018-01-17 15:39:18
    冒泡 选择 插入法 好
  • C语言排序法介绍.docx
  • C语言排序和查找

    千次阅读 多人点赞 2016-05-13 07:23:51
    1.C语言选择排序算法及代码 选择排序排序算法的一种,这里以从小到大排序为例进行讲解。 基本思想及举例说明 选择排序(从小到大)的基本思想是,首先,选出最小的数,放在第一个位置;然后,选出第二小的数,...
  • C语言排序算法.zip

    2020-04-14 15:52:58
    包括7种排序 直接插入排序、希尔排序、快速排序、简单选择排序、堆排序、归并排序、基数排序C语言实现。
  • C语言排序算法的分析和总结.pdf
  • 基于C语言排序的算法改进与应用.pdf
  • C语言排序法介绍.rar

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 147,182
精华内容 58,872
关键字:

c语言排序

c语言 订阅