精华内容
下载资源
问答
  • C语言排序

    千次阅读 多人点赞 2017-07-10 22:27:02
    C语言排序

    排序算法

    快速排序

    C语言快速排序qsort(数组,长度,元素大小,cmp函数(*,*))//注意函数cmp的参数为指针

    #include <stdio.h>
    #include <stdlib.h>
    #include <stdlib.h>   //qsort函数
    int cmp (int a,int b)
    {
        return a -b;
    }
     
    //0 3 2 1 4 5 6 9 8 7
    int main()
    {
        inta[10],i,x;
        for(i=0;i<10; i++)
        {
           scanf("%d",&a[i]);
        }
       qsort(a,10,sizeof(a[0]),cmp);
        for(i=0;i<10; i++)
        {
          printf("%d ",a[i]);
        }
        return 0;
    }
    自定义qsort
     
    void qsort2(int a[],int l,int r){
        if(l<r){
            inti=l,j=r;
            intk=a[i];
           while(i<j){
               while(i<j&&a[j]>=k){
                   j--;
                }
                a[i]=a[j];
               while(i<j&&a[i]<=k){
                   i++;
                }
               a[j]=a[i];
            }
            a[i]=k;
           qsort2(a,l,i-1);
           qsort2(a,i+1,r);
        }
    }

    冒泡排序

    void bubble(int a[],int n)
    {
        int i,j;
        for(i=0;i<n-1; i++)
        {
           for(j=n-1; j>i; j--)
            {
               if(a[j]<a[j-1])
                {
                   int t=a[j];
                   a[j]=a[j-1];
                   a[j-1]=t;
                }
            }
        }
    }

    归并排序

    void merge(int a[],int l,int m,int r){
        inttemp[r-l+1];
        inti=l,j=m+1,k=0;
       while(i<=m&&j<=r){
           if(a[i]<a[j])temp[k++]=a[i++];
            elsetemp[k++]=a[j++];
        }
       while(i<=m){
           temp[k++]=a[i++];
        }
       while(j<=r){
           temp[k++]=a[j++];
        }
       for(i=0;i<k;i++){
           a[l+i]=temp[i];
        }
    }
     
    void mergeSort(int a[],int l,int r){
        if(l<r){
            intm=(l+r)/2;
           mergeSort(a,l,m);
           mergeSort(a,m+1,r);
           merge(a,l,m,r);
        }
    }

    选择排序

    void selectSort(int a[],int n){
        int i,j;
       for(i=0;i<n;i++){
            intk=i;
           for(j=i+1;j<n;j++){
               if(a[j]>a[k]){
                   k=j;
                }
               if(k!=i){
                   int t=a[i];
                   a[i]=a[k];
                   a[k]=t;
                }
            }
        }
     
    }

    堆排序

    #include <stdio.h>
    #include <stdlib.h>
     
    typedef struct heap_t{
           int *arr;         //point for an array to store heap value.
           intheapMaxIndex; //heap element max indexnumber
           intarrLength; //array length of arr
     
    }Heap;
     
     
    void printArr(int *p, int size)
    {
           int i;
           for(i=0;i<size;i++)
           {
                  printf("%d",p[i]);
           }
    }
     
    void maxHeapify(Heap *hp, unsigned int nodei)
    {
           unsignedint l = (nodei+1) << 1 - 1;  //leftchild = 2i-1, -1 ?:arr[0..n-1]
           unsignedint r = (nodei+1) << 1 ;      //right child = 2i
           unsignedint largest = 0;
           intheapMaxI = hp->heapMaxIndex;
     
           if(l<= heapMaxI && hp->arr[l] > hp->arr[nodei])
                  largest= l ;
           else
                  largest= nodei ;
     
           if(r<= heapMaxI && hp->arr[r] > hp->arr[largest])
                  largest= r ;
     
           if(largest!=nodei)
           {
                  //exchange
                  inttmp ;
                  tmp= hp->arr[largest];
                  hp->arr[largest]= hp->arr[nodei];
                  hp->arr[nodei]= tmp;
     
                  maxHeapify(hp,largest);
           }else{
                  return;
           }
     
    }
     
     
    Heap *createHeap(int *arrp, int arrLength,Heap *heap)
    {
     int i;
     heap->arr =arrp;
     heap->heapMaxIndex = arrLength-1;
     heap->arrLength = arrLength;
     
     //for an heapa[0..n-1]; a[(n/2)..n-1] all are leaves
     for(i =arrLength>>1-1; i >=0; i--)
     maxHeapify(heap,i);
     return heap;
    }
     
     
    void heapSort(Heap *hp)
    {
           int tmp;
           int last;
           while(hp->heapMaxIndex>0)
           {
                  last= hp->heapMaxIndex ;
                  //exchange
                  tmp= hp->arr[last];
                  hp->arr[last]= hp->arr[0];
                  hp->arr[0]= tmp;
                  hp->heapMaxIndex-= 1;
                  maxHeapify(hp,0); //make heap from root node 0 to heapMaxIndex
           }
     
    }
     
    int main()
    {
           inta[]={15,25,32,23,1,-4,35,2,-85,42,0,12,26,56,45,12,145,17,25,21};
           printArr(a,20);
           printf("\n");
     
           Heaphpa,*phpa;
           phpa=  createHeap(a,20,&hpa);
           heapSort(phpa);
     
           printArr(a,20);
           putchar('\n');
           return 0;
    }


    展开全文
  • c语言排序

    2017-09-02 11:18:20
    C语言排序简介 C语言排序分为以下几类: 1、冒泡排序 2、选择排序 3、插入排序 4、希尔排序(最快) 5、堆排序 6、快速排序(常用) 一、冒泡排序 冒泡排序(从小到大),每一个值和下一个值比较,如果满足...

    C语言排序简介

    C语言排序分为以下几类:

    1、冒泡排序

    2、选择排序

    3、插入排序

    4、希尔排序(最快)

    5、堆排序

    6、快速排序(常用)

    一、冒泡排序

    冒泡排序(从小到大),每一个值和下一个值比较,如果满足条件就交换。

    如一个数组10,9,8,7,6,5,4,3,2,1.

    9 8 7 6 5 4 3 2 1 10

    8 7 6 5 4 3 2 1 9 10

    7 6 5 4 3 2 1 8 9 10

    6 5 4 3 2 1 7 8 9 10

    5 4 3 2 1 6 7 8 9 10

    4 3 2 1 5 6 7 8 9 10

    3 2 1 4 5 6 7 8 9 10

    2 1 3 4 5 6 7 8 9 10

    1 2 3 4 5 6 7 8 9 10 

     

    每一次排序把最大的像鱼泡一样吧最大值冒到最左边

    程序如下:

    #include <stdio.h>

     

    void swap(int a[],int i,int j)//交换函数

    {

    int temp;

    temp = a[i];

    a[i] = a[j];

    a[j] = temp;

    }

     

    void print(int a[])//打印函数

    {

    int i;

    for(i = 0 ;i < 10;i++)

    {

    printf("%d ",a[i]);

    }

    printf("\n");

    }

     

    void maopao(int a[])//冒泡排序

    {

    int i,j;

    for (i = 0; i < 9; ++i)

    {

    for(j = 0; j < 9 - i;j++)

    {

    if (a[j] > a[j+1])

    {

    swap(a,j,j+1);

    }

    }

    print(a);

    }

        printf("\n");

    }

     

     

     

    int main()

    {

    int a[10] = {10,9,8,7,6,5,4,3,2,1};

    maopao(a);

    print(a);

     

        return 0;

    }

    展开全文
  • 主要为大家详细介绍了C语言排序算法之插入排序,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 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语言实现的基本冒泡排序实现方法及增设flag标志位的改进型算法,需要的朋友可以参考下
  • C语言排序算法

    2021-01-01 13:57:25
    C语言排序算法 1.冒泡排序 void BubbleSort(int a[],int n) { int i,j,t,flag=0;//flag用来标记是否发生交换 for(i=0;i<n;i++) { for(j=n-1;j>i;j--) { if(a[j-1]>a[j])//交换数据 { t=...

    C语言排序算法

    1.冒泡排序

    void BubbleSort(int a[],int n)
    {
    	int i,j,t,flag=0;//flag用来标记是否发生交换 
    	for(i=0;i<n;i++)
    	{
    		for(j=n-1;j>i;j--)
    		{
    			if(a[j-1]>a[j])//交换数据 
    			{
    				t=a[j-1];
    				a[j-1]=a[j];
    				a[j]=t;
    				flag=1;//有数据交换,设置标志变量 
    			}
    		}
    		if(flag==0)//没发生交换,直接跳出循环 
    		break;
    		else
    		flag=0;
    	}
     }
    
    展开全文
  • 本文给大家分享两种常用的C语言排序算法,代码非常简单,感兴趣的朋友可以参考下
  • C语言排序算法.zip

    2020-04-14 15:52:58
    包括7种排序 直接插入排序、希尔排序、快速排序、简单选择排序、堆排序、归并排序、基数排序C语言实现。
  • 几种c语言排序优缺点

    2010-05-12 17:13:55
    几种c语言排序的方法和优缺点,对C语言算法有兴趣的欢迎下载。
  • C语言排序方法冒泡法、选择法、插入法、折半查找法,这几种方法如何区别呢?代码分别如何表达呢?求大侠指点
  • C语言排序函数qsort( )

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

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

    千次阅读 2018-11-08 22:21:43
    C语言排序之冒泡法(起泡法)@C语言排序之冒泡法(起泡法) 冒泡的本质还是两两比较,第一次把最大或最小的选出来,第二次把老二选出来,这样的话就会少比一次,就这样循环下去就行啦,无非就是循环的嵌套,下面是我...
  • c语言排序算法总结

    千次阅读 2012-12-05 14:38:46
    c语言排序算法总结 分类: C 2012-03-26 23:43 436人阅读 评论(0) 收藏 举报 一 理论 1、稳定排序和非稳定排序 简单地说就是所有相等的数经过某种排序方法后,仍能保持它们在排序之前的相对次序,...
  • 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 ...
  • 用指针实现的C语言排序算法,这是我们班的同学集体智慧的结晶
  • c语言排序算法 动画效果展示

    千次阅读 2013-10-13 20:12:56
    c语言排序算法可视化展示地址---手动查看版本:http://www.sorting-algorithms.com/ c语言排序算法可视化展示地址---视频制作版本:http://v.youku.com/v_show/id_XNjIwNTEzMTA0.html
  • int cmp(const void *a,const void *b){ return *(int *)a-*(int *)b;}qsort(s3,f,sizeof(int),cmp);c语言排序函数!!!!#define swap(a,b) (a+=b,b=a-b,a-=b)swap(x,y);c语言交换值函数!!!...
  • C语言 排序大全

    千次阅读 2019-03-18 00:02:24
    插入排序 插入排序虽然不是最有效的排序方法,但它简单,并且不需要额外的存储空间。其最佳应用场景是对一个小的数据集合进行递增排序。 快速排序 在一般情况下,一致认为快速排序是最好的一种排序算法,而且不需要...
  • (c语言排序算法)sort.c

    2020-12-24 11:04:29
    排序算法:直接插入、折半插入排序、希尔排序、冒泡、快排、选择排序、堆排序、归并排序算法c语言实现,带有简要的注释(并非详解)
  • c语言常用的冒泡、简单选择、直接插入、快速排序函数代码
  • C语言排序算法实现

    千次阅读 2017-04-08 14:13:13
    C语言各种排序 算法复杂度以及稳定性分析 算法名称 平均时间 辅助空间 稳定性 冒泡排序 O(n2) O(1) 是 选择排序 O(n2) O(1) 否 插入排序 O(n2) O(1) 是 自底向上归并...
  • C语言所有排序大全,解决了您日常上课考试学习的需要,在这里每一个程序都没有错误,其中压缩包包括了归并排序;基数排序;快速排序;冒泡排序;选择排序;折半排序;希尔排序这些日常排序,因为是全集所以大家踊跃...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,629
精华内容 7,851
关键字:

c语言排序

c语言 订阅