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

    千次阅读 2019-03-25 19:56:34
    输入某门课的成绩,按编程将分数从高到低顺序进行排序输出 第一种:采用交换法排序,也称作冒泡排序。 基本过程是先将第一个数分别于后面的数一个一个进行比较,若后面的数小,则交换后面这个数和第一个数的位置,...

    输入某门课的成绩,按编程将分数从高到低顺序进行排序输出

    第一种:采用交换法排序,也称作冒泡排序。
    基本过程是先将第一个数分别于后面的数一个一个进行比较,若后面的数小,则交换后面这个数和第一个数的位置,否则不交换,一轮比较结束后就求出了一个最小值的数放在了第一位。然后进入第二轮比较,即在其余的数中再按此法求出一个最小的数放在第二个数的位置,再第三次……
    n个数比较总共需要n-1轮

    简单实现

    代码片

    //输入待排序的n个数
     for(i=0;i<n-1;i++)
    	{
    		for(j=i+1;j<n;j++)
    		{
    		//小于号从小到大排序,大于号则相反
    			if(score[j]<score[i])
    			{
    			//实现两个数的交换
    				int temp;
    				temp=score[i];
    				score[i]=score[j];
    				score[j]=temp;
    				
    				int temp1;
    				temp=num[i];
    				num[i]=num[j];
    				num[j]=temp;
    			}
    		}
    	}
    

    如何实现两个数的交换呢?
    你可以试想一下一个瓶子里装的是酱油,一个瓶子里装的是醋,想要让这两个瓶子里装的东西换一下,我们是不是需要另外一个空瓶子呢,显然这里也是同样的。变量temp起到了空瓶子的作用,叫做中间变量。

    向函数传递一维数组

    由于实参变量与形参变量间的数据传递方式是“单向值的传递”,即数据只能由实参转向形参,而不能有形参传回实参。所有的实参实际上都是按值传递,就是将函数调用的实参值复制后得到她的一个副本,然后将这个副本传递给被调函数,因此即使被调函数修改了这个副本,但是他不会传值给实参,所以主调函数(带有实参值得函数)的值不会改变。所以要使用指针或引用的方法解决这个问题。
    但在这里只做排序算法,不具体介绍。
    C语言中,不带任何下标的数组名代表数组的首地址,因此采用数组名作为函数参数的格式为
    数组类型 数组名[ ]
    不进行下标边界检查,里面的数字可以不写。只是另函数接受数组的首地址,通过间接寻址访问主调函数的数组元素,编译器只是检查方括号的数组是否大于0,数组为负数则报错。
    同时可以用一个参数传递数组的长度,知道被访问的数组边界在哪,避免缓冲区溢出(数据写到了数组边界之外,引起程序崩溃)

    代码片

    #include <stdio.h>
    void sort(int score[],int num[],int n);//函数声明
    int main()
    {
    	int n,i,j;
    	int num[40];
    	int score[40];
    	printf("请输入学生的人数:");
    	scanf("%d",&n);
    	for(i=0;i<n;i++)
    	{
    		scanf("%d%d",&num[i],&score[i]);	
    	}
    	sort(score,num,n);
    	printf("输出排序结果\n");
    	for(i=0;i<n;i++)
    	{
    		printf("%d\t%d\n",num[i],score[i]);
    	}
    	return 0;	 
     } 
     //函数定义
    void sort(int score[],int num[],int n)
    {
    	int i,j;
    	for(i=0;i<n-1;i++)
    	{
    		for(j=i+1;j<n;j++)
    		{
    			if(score[j]<score[i])
    			{
    				int temp;
    				temp=score[i];
    				score[i]=score[j];
    				score[j]=temp;
    				
    				int temp1;
    				temp=num[i];
    				num[i]=num[j];
    				num[j]=temp;
    			}
    		}
    	}
    }
    

    上述排序效率太低,第i+1个数和后面的数都要一一比较。事实上,我们可以找出余下数的最大值再和第i+1个数交换位置,这样每轮比较最多只有一次交换操作。这种改进算法称为选择法排序。

    代码片

    下面是函数封装的排序

    void sort(int score[],int num[],int n)
    {
    	int i,j,k;
    	for(i=0;i<n-1;i++)
    	{
    		k=i;
    		for(j=i+1;j<n;j++)
    		{
    			if(score[j]>score[k])//按降序排列
    				k=j;
    		}
    		if(k!=i)//若k中记录的最大数序号不是i,即找到的最大数不在i的位置
    			{
    				int temp;
    				temp=score[k];
    				score[k]=score[i];
    				score[i]=temp;
    				
    				int temp1;
    				temp=num[k];
    				num[k]=num[i];
    				num[i]=temp;
    			}
    	}
    }
    

    下一篇介绍C语言查找算法。

    展开全文
  • 数组的基本概念: 批量创建一组相同类型的变量。 创建数组: //创建数组 int arr[4] = { 1, 2, 3, 4 }; //批量创建了一组int类型的变量。 //有4个变量 数组名字为arr //把初始值一次的设置进{} a)[4]中的4可以省略...

    数组的基本概念:
    批量创建一组相同类型的变量。

    创建数组:

    //创建数组
    int arr[4] = { 1, 2, 3, 4 };
    //批量创建了一组int类型的变量。
    //有4个变量 数组名字为arr
    //把初始值一次的设置进{}
    

    a)[4]中的4可以省略,但数组的长度就和后面初始化的列表里的元素个数一致
    b)[4]如果不省略的时候,后面的初始化列表的元素不能比4个多。
    c)[4]如果不省略的时候,后面的初始化列表的元素可以比4个少,剩下的元素填成0.
    d)创建数组的时候,[ ]里面的数字只能是一个常量,不能是变量。(C89中)
    可以这样

    #define size 4
    
    char arr[size] = {0};
    
    enum{
        size = 4,
    };
        
    char arr[size] = {0};    
    

    e)如果省略了[4]中的数字,就一定要使用{ }进行初始化。

    int arr[];
    //这样就会编译不了
    

    f)如果没有省略[4]的数字,并且也没有进行初始化直接进行打印就会打印出内存的残留值

    #include<stdio.h>
    
    int main(){
        inr arr[4];
        printf("s",arr[4]);
        return 0;
    }    
    

    如果是一个全局变量,没有被显式初始化,会被自动初始化为0.
    如果是一个巨擘变量,没有被显式初始化,就是上次残留的值.

    //针对字符数组的初始化
    //可以向普通数组一样使用{}初始化
    //也可以使用""来用一个字符串进行初始化
    char str1[] = { 'a', 'b', 'c' };//字符数组
    char str3[] = "abc"; //字符串
    

    不是每个字符数组都可以成为"字符串",
    字符串是一种特殊的字符数组,一定是以/0来结尾。
    给任何str系列的函数(strlen,strcmp…)进行传参的时候,必须要由人来保证参数是一个合法的字符串。

    数组的使用:
    1.求数组长度

     sizeof(arr) / sizeof(arr[0])
    

    2.取下标~[]
    从0开始 到 len-1结束。
    一旦下标越界,就是未定义行为!

    #include<stdio.h>
    
    #int main(){
         int arr[10] = { 0 };
         for(int i = 0 ; i < 10; i++){
             arr[i] = i + 1;
         }
         for(int i = 0; i < 10; i++ ){
             printf("%d\n",arr[i]);
         }
         return 0;
    }        
         
    

    一维数组在内存中的存储

    #include<stdio.h>
    
    int main(){
        char arr[10] = {0};
        for(int i = 0; i < 10; i++){
            printf("%p\n",&arr[i]); //打印地址使用%p
         }
         return 0;
    }        
    

    将char改为short 就会发现输出的地址会依次差2, 改为int 依次差4

    数组中的元素处在连续的内存空间上~

    二维数组:

    本质上还是一个一维数组,只不过每个元素又是一个一维数组。
    所谓的数组,也就可以理解成一种特殊的类型。
    int arr[4]; 可以理解成是创建了4个int类型的变量,也可以理解成创建了一个变量arr,类型是int[4].

    **三维数组:**本质上也是一个一维数组,只不过每个元素又是一个二维数组~

    不管是几位数组,本质上都是一维数组,操作/语法都是和一维数组相同的。
    ——————

        //arr => array
        int arr[3][4] = { 0 };
        
    

    进行调试就会看到![在这里插入图片描述](https://img-blog.csdnimg.cn/20210422205439634.png

    是一个长度为3的一维数组,每个元素又是长度为4的一维数组构成。
    3行4列
    常见的写法:
    第一种:

    int arr[3][4]={ 1, 2, 3, 4, 5 };
    

    在这里插入图片描述

    第二种:

    int arr[3][4]={
         {1,2}
         {3,4}
         {5}
     }    
    

    在这里插入图片描述

    当我们写成

    int arr[3][4]={
        (1, 2),
        (3, 4),
        (5)
     };
    

    就会有这样的结果
    在这里插入图片描述

    (1,2),
    

    这种叫做逗号表达式~
    a,b =>的值就是最后一个逗号的值.(没啥用)

    int arr[3][4]={
            2, 4, 5   //这样就等同于上面的写法
            };
    

    _
    当我们省略掉[3]里的3时候

    int arr[][4]={
        2, 4 ,5
    };
    

    就会默认为1行.
    但是并不能省略[4]里的4 如果省略了,这时候就会报错.
    对于二维数组 或者三维四维等更高维的数组, 只能省略第一个[]中的数组,后续的数字就不能省略~
    这件事还是和一维数组的规则是一致的~

    二维数组的使用
    取下标.

    #include<stdio.h>
    
    int main(){
      int arr[3][4]={
        2, 4, 5
       };
       for(int row = 0 ;row < 3; row++){
           //相当于取出其中的某一行 ,这一行是一个数组.
           for(int col = 0 ; col < 4 ; col ++){
           //相当于对取出的一维数组再取下标 就可以得到其中的元素了.
           printf("%d",arr[row][col]);
           }
           printf("\n");
       }
       return 0;
    }    
    

    二维数组在内存中的存储
    二维数组在内存中也是在一个连续的内存空间上存储的~

    #include<stdio.h>
    
    int main(){
      int arr[3][4]={
        2, 4, 5
       };
       for(int row = 0 ;row < 3; row++){
           //相当于取出其中的某一行 ,这一行是一个数组.
           for(int col = 0 ; col < 4 ; col ++){
           //相当于对取出的一维数组再取下标 就可以得到其中的元素了.
           printf("%p",&arr[row][col]);
           }
           printf("\n");
       }
       return 0;
    }   
    

    运行程序后就可以看到数组的元素是在连续的内存空间上存储的在这里插入图片描述

    数组作为函数参数

    数组名作为函数的参数也会触发转成指针的操作.
    在函数内部是无法直接求数组的长度的,必须要在函数外面提前把长度秋毫,再以参数的形式传给函数内部.
    冒泡排序~
    基本思路: 比较两个相邻的元素 查看是否符合排序的要求(升序/降序),如果不符合排序要求,就进行交换元素.
    从前往后遍历,每次取出一个最大的元素放到数组最后.
    从后往前遍历,每次取出一个最小的元素放到数组最前面.

    #include<stdio.h>
    
    void bubbleSort(int arr[], int size){
         //从后往前遍历
         //每次从后往前遍历比较相邻元素
         // bound => 边界使用这个值,表示已排序区间和待排序区间的分界线
         //[0,bound) 已排序区间
         //[bound,size) 待排序区间
         int bound = 0;
         for(;bound < size; bound++){
         //通过这个循环 来控制后续的比较相邻元素的比较趟数.
         //接下来实现一趟比较交换的过程
             for(int cur = size - 1;cur > bound;cur--){
             //相邻元素 以cur为基准, cur - 1
                if(arr[cur - 1] > arr[cur]){
                int tmp = arr[cur - 1];
                arr[cur - 1] = arr[cur];
                arr[cur] = tmp ;
                }
             }
          }      
    }
    int main(){
        int arr[6] = {9, 5, 2, 7, 3, 6};
        int size = sizeof(arr) / sizeof(arr[0]);
        bubbleSort(arr,size);
        for(int i = 0; i < 6; i++){
            printf("%d ",arr[i]);
            }
            printf("\n");
            return 0;
    }
    
    展开全文
  • } printf("----------对每一行进行排序\n"); for(int i=0;i;i++)//控制数组的行 { for(int k=0;k;k++){//控制列进行比较大小 for(int j=0;j;j++){ //控制数组的列 if(sum[i][j] { int temp=sum[i][j]; sum[i][j]=...

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    这是我的代码、、问题出在换行的时候sum[i][j]的值还保存着上一行的值、、

    #include "stdafx.h"

    #include"stdio.h"

    int main(){

    int sum[3][4]={{2,3,4,5},{4,3,2,5},{1,3,5,9}};

    for(int i=0;i<3;i++)

    {

    for(int j=0;j<4;j++)

    {

    printf(" %d",sum[i][j]);

    }

    printf("\n");

    }

    printf("----------对每一行进行排序\n");

    for(int i=0;i<3;i++)//控制数组的行

    {

    for(int k=0;k<4;k++){//控制列进行比较大小

    for(int j=0;j<4-k;j++){ //控制数组的列

    if(sum[i][j]

    { int temp=sum[i][j];

    sum[i][j]=sum[i][j+1];

    sum[i][j+1]=temp;

    }

    }

    }

    }

    for(int i=0;i<3;i++)

    { for(int j=0;j<4;j++)

    {

    printf(" %d",sum[i][j]);

    }

    printf("\n");

    }

    getchar();

    return 0;

    }

    展开全文
  • 已知某次比赛共有10组参赛小组,每组12名选手,各选手的成绩按组保存在数组score[10][12]中, 要求按每组总分降序的顺序输出选手成绩。/ #include #define M 10 #define N 12 void main() { float score[M][N+1]={0...
  • 第 1 行为字母 A 或 D,A 表示按照升序排序,D 表示按照降序排序。 第 2 行开始有若干个用一个空格或换行符分隔的正整数。 输出格式 相互之间用一个空格分隔的经去重和排序后的正整数。最后一个数后没有空格。 ...
  • 1:题目: 将数组16 25 9 90 23 降序排序

    1:题目: 将数组16 25 9 90 23 降序排序

    思路:
    冒泡排序的基本原理,遍历和交换
    第一轮循环;如果某个数字小于后面的数字,那么就交换
    1 25 16 9 90 23
    2 25 16 9 90 23
    3 25 16 90 9 23
    4 25 16 90 23 9
    需要比较多轮,数组长度-1轮
    每轮比较的次数(数组长度-1)-当前的轮数

    #include <stdio.h>
    #include <stdlib.h>
    #define N 5
    int main()
    {
        int i,j;
        int temp;
        int nums[N] = {16,25,9,90,23 };
        //外层循环控制轮数
        for (i = 0; i < N - 1; i++)
        {
            //内层循环控制每轮比较的次数
            for (j = 0; j < N - i-1; j++)
                //如果当前值小于后面一个数,则交换
            {
                if (nums[j] < nums[j + 1])
                {
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
        printf("排序后的结果是: \n");
        for (i = 0; i < N; i++)
        {
            printf("%d\t", nums[i]);
        }
    
        for (i = 0; i < N - 1; i++)
        {
            //内层循环控制每轮比较的次数
            for (j = 0; j < N - i - 1; j++)
                //如果当前值小于后面一个数,则交换
            {
                if (nums[j] > nums[j + 1])
                {
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
        printf("排序后的结果是: \n");
        for (i = 0; i < N; i++)
        {
            printf("%d\t", nums[i]);
        }   
        }
    
    展开全文
  • 设计一子函数用冒泡排序法对8个元素的一维整型数组降序排序。一维数组元素从键盘输入。 要求: 1、使用子函数: void Sort(int a[],int n)//n是数组元素个数。 2、在子函数中实现排序,不允许在子函数中输出。 ...
  • 返回:贺老师课程教学链接项目要求【项目3 - 数组排序】(1)编写函数,完成冒泡排序要求不能改变下面的main函数。//两个函数bubble_sort和output_array的声明int main( ){int a[20]={86,76,62,58,77,85,92,80,96,88...
  • 通常会遇到将数组中元素排序的问题,那可能会有很多方法去解决这个问题例如冒泡排序,快速排序等等,但是实际上C语言中本身有一个自带的快速排序的函数qsort()。 首先来看一下qsort()函数的定义:qsort(void * base,...
  • //找到比他大的,替换数组中的元素,数组中元素取出来保存 int tempNum=num[i]; num[i]=insertNum; insertNum=tempNum; } } //insert(num, 51); printf("插入数字后新数组为:\n"); for (int i=0; i; i++) {...
  • 写一个函数,对任意一维数组进行降序 排序。在主函数中随机生成一有n个元 素的一维数组(元素的取值范围载10-90 之间),调用排序函数对该数组进行排 序,并输出排序结果。
  • 求助帖 C语言 数组去重排序 P.S.题目来自EOJ P.S.S.这是一道水题 P.S.S.S.这是一篇求助帖 所以代码是有问题的 /*本来抱着快过刷分的心理做的这道题,但无奈水平有限,提交之后在某个样例上一直runtime error。 ...
  • C语言数组进行排序

    千次阅读 2019-03-17 20:08:15
    C语言数组进行排序 思维:冒泡法排序 #include &lt;stdio.h&gt; int main() { int a[3] = { 1, 5, 7 }; int i = 0; int j = 0; for (i = 0; i &lt; 2; i++) { for (j = 0; j &lt; 2 - i; j+...
  • 用冒泡法和选择法对10个整数排序C语言 数组

    万次阅读 多人点赞 2018-05-22 00:38:31
    可以进行升序或降序排序。 选择法是每趟选出一个最值确定其在结果序列中的位置,确定元素的位置是从前往后,而每趟最多进行一次交换,其余元素的相对位置不变。可进行降序排序或升序排序。2.冒泡法:...
  • C语言数组

    2018-12-22 11:39:16
    1,一维数组的定义和初始化:  数组是一组具有相同类型的变量的集合。使用一个统一的名字来标识这组相同类型的数据,这个名字称为数组名,构成... 注意:C语言数组的下标都是从0开始的。如果对一个数组而言,例...
  • 萌新求教C语言降序排序数列

    千次阅读 2018-12-30 21:45:30
    萌新求教C语言降序排序数列 int main() { int a[20]; int i,j,t; printf(&quot;排序前的数:\n&quot;); for(i=0;i&amp;lt;20;i++) { scanf(&quot;%d&quot;,&amp;amp;a[i]); ...
  • 好玩的C语言数组!!(冒泡排序数组)

    千次阅读 多人点赞 2016-08-03 17:24:15
    首先理解什么是数组数组就是一组数据的集合。它的定义格式是数据类型 数组名[数据长度]; 或者 数据类型 数组名[数组长度]={}; 或者 数据类型 数组名[3]={1,2,3}; 数组内的数据用逗号分隔。 数组的初始化可以...
  • C语言数组的几种排序方法

    千次阅读 2019-08-23 15:46:38
    #include <stdio.h> #include <time.h>.../*快速排序法*/ void quickSort(int *p,int low,int high) { if(low < high) { int temp = p[low]; int l = low; int h = high; ...
  • C语言——利用数组处理批量数据第六章 本章要点 主要内容 6.1 为什么要用数组 6.2 定义和引用一维数组 6.3 二维数组的定义和引用 6.4 字符数组 6.5 提高部分 6.1 为什么要用数组 #####C语言的标识符命名规则 (1)...
  • 【独立编程】程序功能:输入正整数 n(n≤10)和n个整数存入数组a,先用冒泡排序法对数组a按降序排序,再输出排序后的a数组。 #include<stdio.h> int main(){ int a[10]; int i,n; void sort(int *p,int n...
  • C语言成绩数组排序

    2020-12-26 19:09:23
    由键盘输入30名同学的成绩,按成绩由高到低去排序并输出排序后的成绩。 主函数输入30名学生的成绩,输出排序后的成绩; 子函数中对30个成绩排序; #include<stdio.h> #define N 30 int main() { int ans[N],i...
  • 要求编写5个函数,分别实现计算考试的总分,最高分,最低分,平均分和考试成绩降序排序。我的代码如下:#include #define N 10void printscore(int score[]){int i;printf("\n");for(i=0;i{printf("...
  • c语言数组小谈

    2017-12-31 14:49:00
    "降序排序后的顺序为: \n " ); for (i= 0 ;i;i++) { printf ( "输入第%d个数字为:%d \n " ,i,arr[i]); } return 0 ; } // 冒泡函数 void bubble_sort ( int a[], int n) { int i,j,temp;...
  • math对象:提供数学相关的一些运算 math.floor 向下取整 math.ceil 向上取整 math.round 四舍五入 random 产生一个[0,1)内的随机数 随机产生一个[n,m+n)内的随机数 math.floor( math....数组.length 获取数组...
  • 输入若干个字符串放入二维数组中,怎样才可以进行降序输出啊
  • 利用C语言可以实现对数组的各种操作,如输入数组元素,输出数组元素、求数组元素平均值、输出数组元素最大值、输出数组元素最小值、查找某数值元素是否存在、给数组元素排序等功能。本压缩文件中是上述功能对应的...
  • c语言中冒泡法排序的算法:1、从数组头部开始,不断比较相邻的两个元素的大小,让较大的元素逐渐往后移动(交换两个元素的值),直到数组的末尾。2、经过第一轮的比较,就可以找到最大的元素,并将它移动到最后一个...

空空如也

空空如也

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

c语言数组降序排序

c语言 订阅