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

    2014-10-21 20:45:42
    char strings[4][50]={"iOS", "Cocos2D-X",  "Android","Unity3D"};   for(int i=0;i4-1;i++)  {   for(int j=0;... {//条件判断,当strcmp的返回值大于0的时候,是按照降序排列的,要交换位置


    int main(int argc, const char * argv[]) {

       

        //回想一维数组定义方式

        //类型修饰符 数组名[元素个数] = {初始值...}

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

        //创建一个二维数组

        //类型修饰符 数组名[包含几个小数组][每个小数组有多少个元素]={初始值}

        //初始值如何写?

    //    int array[3][4]={{1, 2, 3, 4},

    //                     {5, 6, 7, 8},

    //                  {9, 10, 11, 12}};

        //一维数组可以省略元素个数,二维数组只能省略第一位(第一个[3]可以不写)

        //第二种初始值写法

    //    int array[3][4]={1, 2, 3, 4,

    //                     5, 6, 7, 8, 9,

    //                     10, 11, 12};

    //    

    //    printf( "%d", array[1][2]);

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

    //    //第一重循环,遍历小数组

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

    //    {

    //        //第二重循环,遍历小数组元素

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

    //        {

    //            //给每个元素赋值,随机范围0~49

    //            array[i][j] = arc4random() % 50;

    //                   //输出每个元素

    //                   printf("%2d ",array[i][j]);

    //        }

    //                   //相当于小数组遍历完毕,添加换行符

    //                   printf("\n");

    //    }

    //      // 练习:将一个⼆二维数组的⾏和列交换,存储到另外一个数组中去。

    //    printf("改变后");

    //    int dest[4][3]={0};

    //    for(int i =0;i<4;i++)

    //    {

    //        for(int j =0;j<3;j++)

    //        {

    //            dest[i][j]=array[j][i];

    //    printf("%2d ",dest[i][j]);

    //           }

    //         printf("\n");

    //    }

    //美观美观

       

        //练习:有一个3⾏行4列的⼆二维数组,要求编程找出最⼤大元素,并输出所在 的⾏行和列

        //定义一个变量保存最大值,方法1

    //    int max =0;

    //    //定义两个变量保存位置

    //    int row =0,col=0;

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

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

    //    {

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

    //        {

    //            array[i][j] = arc4random() % 50;

    //            printf("%2d ",array[i][j]);

    //            //判断最大值

    //            if(max<array[i][j])

    //            {

    //                max=array[i][j];

    //                

    //                //并且记录位置信息

    //                row=i;

    //                col=j;

    //            }

    //        }

    //           printf("\n");

    //    }

    //        printf("%2d ",array[row][col]);

        

        

            


    //  方法2:

        

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

    //    int maxRow=0,maxCol=0;

    //    int max=0;

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

    //    {

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

    //        {

    //                        array[i][j] = arc4random() % 50;

    //                        printf("%2d ",array[i][j]);

    //            if(max<array[i][j])

    //                            {

    //                                max=array[i][j];

    //    

    //                            }

    //            //用当前位置元素与记录的最大值位置元素进行比较,如果大于,则改变

    //            if(array[i][j]>array[maxRow][maxCol])

    //            {

    //                maxRow = i;

    //                maxCol =j;

    //            }

    //        }

    //    }

    //     printf("max =%d\n",array[maxRow][maxCol]);

    //    printf("%d,%d",maxRow,maxCol);

       

    //    //测试元素个数补齐

    //    int array[][3]={{1,2},{4,8,9}};

    //    for(int i =0;i<2;i++)

    //    {

    //        for(int j=0;j<3;j++)

    //        {

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

    //        }

    //        printf("\n");

    //    }

        

        //定义字符串数组

       // char strings[几个字符串][每个字符串的空间大小]{初始值列表};

    //    char  strings[4][50]={"iOS", "Cocos2D-X",

    //        "Android","Unity3D"};

    //    //string[0]就是第一个数组的首地址

    //    //可以理解为恒等于&string[0][0]

    //    //循环输出字符串数组

    //    for(int i=0;i<4;i++)

    //    {

    //    

    //    printf("%s\n",strings[i]);

    //    

    //    }

        

         //  char  strings[4][50]={"iOS", "Cocos2D-X",

         //      "Android","Unity3D"};

    //    //如果打印一个字符,需要用%c

    //   // printf("%c\n",strings[2][2]);

    //    printf("%s\n",&strings[1][5]);

        //2.创建⼀一个字符串数组(内容是你周围⼀一圈⼈人的姓名),输出最⻓

        //字符串的⻓长度。

        //定义一个变量用来存储最长的长度

    //    char  strings[4][50]={"iOS", "Cocos2D-X",

    //        "Android","Unity3D"};

    //    int maxLength=0;

    //    //遍历字符串数组

    //    for(int i =0;i<4;i++)

    //    {

    //    //进行判断

    //        if(strlen(strings[i])>strlen(strings[maxLength]))

    //        {

    //            maxLength=i;

    //           

    //       

    //        }

    //      

    //    }

    //    printf("最长单词是%s",strings[maxLength]);

        //创建一个字符串数组(内容是你周围⼀一圈⼈人的姓名),对字符串 (英⽂文)从小到大排序

        

            char  strings[4][50]={"iOS", "Cocos2D-X",

                "Android","Unity3D"};

        for(int i=0;i<4-1;i++)

        {

            for(int j=0;j<4-i-1;j++)

            {//条件判断,strcmp的返回值大于0的时候,是按照降序排列的,要交换位置

                if(strcmp(strings[j],strings[j+1])>0)

                {

                    //交换字符串

                    //字符串不能直接赋值,需要用字符拷贝函数strcpy

                    char temp[50]={0};

                    strcpy(temp,strings[j]);

                    strcpy(strings[j],strings[j+1]);

                    strcpy(strings[j+1],temp);

                    

                

                }

            

            }

        

        }

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

        {

            printf("%s\n",strings[i]);

        }

        

        //明天考

    //    char  strings[4][50]={"iOS", "Cocos2D-X",

    //        "Android","Unity3D"};

    //    for(int i =0;i<4-1;i++)

    //    {

    //        for(int j=0;j<4-1-i;j++)

    //        {

    //            if(strcmp(strings[j],strings[j+1])>0)

    //            {

    //                char temp[50]={0};

    //                strcpy(temp,strings[j]);

    //                strcpy(strings[j],strings[j+1]);

    //                strcpy(strings[j+1],temp);

    //                

    //            }

    //        }

    //    }

    //    for(int i =0;i<4;i++)

    //    {

    //        printf("%s\n",strings[i]);

    //    }



        

    }



    展开全文
  • 问题描述: ...//设计排序函数,实现数组降序排列:10 9 8 7 6 5 4 3 2 1 empty();//清空数组,全为0 show();//显示数组 程序分析:   程序的思路:a.先将程序的头和尾写好,在主函数中将要被处

    问题描述:

            编写以下四个函数:

    init();//设计函数初始化数组为 1 2 3 4 5 6 7 8 9 10

    sort();//设计排序函数,实现数组的降序排列:10 9 8 7 6 5 4 3 2 1
    empty();//清空数组,全为0

    show();//显示数组

    程序分析:

          程序的思路:a.先将程序的头和尾写好,在主函数中将要被处理的两个参数(一个数组arr,和数组的长度len)。b.再封装那几个函数,额外加上一个menu函数。c.在主函数中用switch case语句调用这几个函数。

    代码如下:

    <pre name="code" class="cpp">/**
    init();//设计函数初始化数组为 1 2 3 4 5 6 7 8 9 10
    sort();//设计排序函数,实现数组的降序排列:10 9 8 7 6 5 4 3 2 1
    empty();//清空数组,全为0
    show();//显示数组**/
    #include<stdio.h>
    #include<stdlib.h>
    #define LENGTH 10	  //宏定义数组的大小
    /***初始化数组****/
    void init(int arr[],int n)
    {
    	int i = 0;
    /**给数组中的每个元素赋值**/	
    	for(i = 0;i < n;i++)
    	{
    		arr[i] = i+1;
    	}
    }
    /***选择排序****/
    void selection_sort(int arr[],int n)
    {
    	int i = 0;     //用下标i表示数组中当前元素
    	int j = 0;	   //用下标j表示这次循环中找到的最大元素的下标
    	int k;		   //用下标k存放每次循环中最大元素的下标
    	int temp;	   //定义中间变量,用于下面的交换
    	for(i = 0;i<n;i++)
    	{
    		k = i;	//假设每次循环中的最大值就是循环中的第一个值的值
    		for(j = i+1;j < n;j++) //从每次循环中的第二个开始与假设的最大值比较
    		{
    			if(arr[j] > arr[k])	//当找到比假设值大的时候,将最大值下标赋给k
    			{
    				k = j;
    			}
    		}
    		if(k != i)	//查找后如果循环中最大值不是假设值
    		{
    			temp = arr[i];	 //交换,使k下标对应的值为每次循环中的最大值
    			arr[i] = arr[k];
    			arr[k] = temp;
    		}	
    	}
    }
    /***冒泡排序****/
    void bubble_sort(int arr[],int n)
    {
    	int i = 0;	 //定义外层循环变量i,并且初始化为0
    	int j = 0;	 //定义内层循环变量j,并且初始化为0
    	int temp;	  //定义中间变量,用于后面的交换
    	for(i = 0;i<n-1;i++)   //外层循环,总共进行n-1趟相邻的两两比较
    	{
    		for(j = 0;j < n-1-i;j++)//内层循环,每趟循环比较n-1-i次
    		{
    			if(arr[j+1]>arr[j])	 //当相邻的两两比较中,后者大于前者,进行交换
    			{
    				temp = arr[j+1];
    				arr[j+1] = arr[j];
    				arr[j] = temp;
    			}	
    		}
    	}	
    
    }
    /***清空数组****/
    void empty(int arr[],int n)	//这个函数时将数组中的所有元素置为0
    {
    	int i = 0;
    	for(i = 0;i < n;i++)
    	{
    		arr[i] = 0;
    	}
    }
    /***打印显示数组****/
    void show(int arr[],int n) //这个函数主要用打印的方式,显示每次调用其他函数后的结果
    {
    	int i = 0; 
    	for(i = 0;i < n;i++)
    	{
    		printf("%d ",arr[i]);
    	}
    	printf("\n");
    
    }
    /***设置菜单****/
    void menu()   //编写menu给用户提供如何使用的信息
    {
    	printf("**************************\n");
    	printf("*********初始化->1********\n");
    	printf("*******冒泡排序->2********\n");
    	printf("*******选择排序->3********\n");
    	printf("********清空->4***********\n");
    	printf("********打印->5***********\n");
    	printf("**************************\n");
    }
    
    int main()
    {
    	int j = 0;
    	int a[10];	  //定义一个大小为10*sizeof(int)的数组
    	int len = sizeof(a)/sizeof(a[0]);  //数组的大小
    	
    	int select;	  //定义select作为switch函数的参数
    	int i = 1;	  //定义并初始化循环变量
    	
    	while(i)
    	{	 
    		menu();	   //调用menu函数
    		printf("请输入功能序号:\n") ;
    		scanf("%d",&select);
    		system("cls");  //这个是清屏的函数,可以在显示前调用这个函数,这样就可以清晰的显示了。
    						//清屏的头文件是"stdlib.h"
    		switch(select)	 //编写switch函数
    		{
    		case 1:
    			init(a,len);
    			break;
    		case 2:
    			bubble_sort(a,len);
    			break;
    		case 3:
    			selection_sort(a,len);
    			break;
    		case 4:
    			empty(a,len);
    			break;
    		case 5:
    			show(a,len);
    			break;
    		default:
    			break;
    		}
    	}
    	return 0;
    }





    
    
    展开全文
  • (1)随机产生20个int类型的数组元素,编写并调用函数用冒泡排序法按降序排列后输出;编写并调用函数用简单选择排序法按降序排列后输出; (2)输入几个英文姓氏,对其进行升序排列。 (3)向一个已经排好序的数组...

    (1)随机产生20个int类型的数组元素,编写并调用函数用冒泡排序法按降序排列后输出;编写并调用函数用简单选择排序法按降序排列后输出;

    (2)输入几个英文姓氏,对其进行升序排列。

    (3)向一个已经排好序的数组a中插入一个数,要求插入后数组仍按原来的规律排序,然后再将该数组的第3个元素删除,请编程实现该操作并显示插入和删除以后的数组。

    #include <stdio.h>
    
    #include <stdlib.h>
    
    #include <time.h>
    
    int nums[20];
    
    int i,j,k,tmp;
    
    
    
    void product_num();
    
    void maopao_rank();
    
    void simple_rank();
    
    
    
    void main(){
    
            printf("请选择排序方式!输入数字1:冒泡排序,2:选择排序\n");
    
            scanf_s("%d",&k);
    
            if(k==1){
    
                product_num();
    
                maopao_rank();
    
            }else if(k==2){
    
                product_num();
    
                simple_rank();
    
            }else{
    
                printf("输入不符请重新输入");
    
            }
    
    }
    
    
    
    void product_num(){
    
        srand((unsigned int)time(NULL));
    
        for(i=0;i<20;i++){
    
            nums[i]=rand()%100;
    
        }
    
    }
    
    void maopao_rank(){
    
        for(j=1;j<20;j++){
    
            for(i=0;i<20-j;i++){
    
                if(nums[i]<nums[i+1]){
    
                    tmp=nums[i];
    
                    nums[i]=nums[i+1];
    
                    nums[i+1]=tmp;
    
                }
    
            }
    
        }
    
        for(i=0;i<20;i++){
    
            printf("%d  ",nums[i]);
    
        }
    
    }
    
    void simple_rank(){
    
        for(j=0;j<19;j++){
    
            int max=j;
    
            for(i=j+1;i<20;i++){
    
                if(nums[i]>nums[max]){
    
                    tmp=nums[max];
    
                    nums[max]=nums[i];
    
                    nums[i]=tmp;
    
                }
    
            }
    
        }
    
        for(i=0;i<20;i++){
    
            printf("%d  ",nums[i]);
    
        }
    
    }

    这里写图片描述


    2:

    #include <stdio.h>
    
    #include <string>
    
    
    
    void main() {
    
        printf("请输入5个英文姓氏");
    
        char *a[5];
    
        char *tmp;
    
        int m = 5, i, j;
    
        for (i = 0; i < m;i++) {
    
            gets(a[i]);
    
        }
    
        for (i = 0; i < m - 1; i++) {
    
            for (j = i + 1; j < m; j++) {
    
                if (strcmp(a[i], a[j]) >0) {
    
                    tmp = a[i];
    
                    a[i] = a[j];
    
                    a[j] = tmp;
    
                }
    
            }
    
        }
    
        for (i = 0; i < m; i++) {
    
            puts(a[i]);
    
        }
    
    }

    这里写图片描述

    3:

    
    
    #include <stdio.h>
    
    void main(){
    
        int a[6]={1,4,9,13,25};
    
        int x,i;
    
    
    
        printf("请输入数字:\n");
    
        scanf("%d",&x);
    
        for(i=4;i>=0;i--){
    
            if(a[i]>x){
    
                a[i+1]=a[i];
    
            }else{
    
                break;
    
            }
    
        }
    
        a[i+1]=x;
    
        printf("插入数组后:\n");
    
        for(i=0;i<6;i++){
    
            printf("%d ",a[i]);;
    
        }
    
        printf("删除数组第三个后:\n");
    
        for(i=2;i<6;i++){
    
            a[i]=a[i+1];
    
        }
    
        for(i=0;i<5;i++){
    
            printf("%d ",a[i]);;
    
        }
    
    }

    这里写图片描述

    展开全文
  • 数组降序5.1.使用list集合以及reverse:先升序排列然后通过倒置,逆序5.2使用Comparator接口,重写sort方法5.3使用Comparator接口,实现对字符串数组的排序6.二维数组7.二维数组-矩阵乘法 1.数组的定义 C语言风格:...

    1.数组的定义

    C语言风格:int a[]={1,5,5,4,5,4};
    java风格(面向对象风格,推荐!) int[] b={2,3,3,5,4,3};

    静态初始化和动态初始化

    int[] a=new int[]{2,423,42,3}//静态初始化
    int[] a={2,3,8,5,3,123}//静态初始化简化版
    int[] c=new int[5]//动态初始化
    int num=sc.nextInt() int[] c=new int[num] 数组初始化的大小取决于用户输入

    动态初始化后系统的默认赋值分别是多少
    在这里插入图片描述

    2.遍历数组

    数组的遍历有普通for循环遍历和foreach遍历两种情况

    	int[] a= {1,34,32,124,31,3};
    		//普通的for循环遍历
    		for (int i = 0; i < a.length; i++) {
    			System.out.println(a[i]);
    		}
    		
    		//foreach循环遍历
    
    		for(int c:a) {
    			//只读,不可修改数据
    			System.out.println(c);
    			//如果修改c的值也只是对读取的当前c值做了修改,并没有改变数组的值
    		}
    

    3.排序

    冒泡排序
    在这里插入图片描述

    冒泡排序的的步骤
    循环
    交换
    回手掏(减少比较次数)

    	public static void foamsort(int[] arr) {
    	    for(int i=arr.length-1;i>0;i--){
    	        boolean flag = false;
    	        for(int j=0;j<i;j++){
    	            if(arr[j] > arr[j+1]){
    	                int tmp = arr[j];
    	                arr[j] = arr[j+1];
    	                arr[j+1] = tmp;
    	                flag = true;
    	            }
    	        }
    	        if(!flag) break;
    	    }
    		for(int a:arr) {
    			System.out.println(a);
    		}
    	}
    

    插入排序

    我用的二分法查找到对应的下标值,返回下标值,然后对于下表后面的元素进行后移

    public static int insertsort(int[] arr,int l,int r,int va) {
    		int mid=l+(r-l)/2;
    		int index=0;
    		if(l<r) {
    			if(arr[mid-1]>va) {
    				crsort(arr, l, mid-1, va);
    			}else if(arr[mid+1]<va) {
    				crsort(arr, mid+1, r, va);
    			}else if(arr[mid-1]<=va&&arr[mid]>=va) {
    				index=mid;
    			}else if(arr[mid+1]>=va&&arr[mid]<=va) {
    				index=mid+1;
    			}
    		}
    		
    		return index;
    	}
    
    

    选择排序:比较大小换位置
    很暴力

    	public static void choosesort(int[] arr) {
    		for (int f = 0; f < arr.length; f++) {
    			for (int i = f+1; i < arr.length; i++) {
    				if(arr[i]<arr[f]) {
    					arr[i]=arr[f]+arr[i];
    					arr[f]=arr[i]-arr[f];
    					arr[i]=arr[i]-arr[f];
    				}
    			}
    		}
    		for(int a:arr) {
    			System.out.println(a);
    		}
    	}
    

    4.Arrays类

    Arrays类的总结来自己虎老狮,大家可以去关注一波微信公众号获取知乎

    import java.util.Arrays;
    public class TestArrays{
    	public static void main(String[] args) {
    		int[] arr1 = { 2, 1, 5, 4, 3 };
    		String sArr1 = Arrays.toString(arr1);// 数组转为字符串
    		System.out.println(sArr1);
    		// Arrays.sort(arr1);//排序(升序)
    		Arrays.parallelSort(arr1);// Java 8的并行排序,支持多核CPU,更快
    		System.out.println("排序后:" +Arrays.toString(arr1));
    		// Arrays.binarySearch:(升序排列的数组)二分查找
    		// 参数2是要查找的元素。
    		// 返回值为索引;找不到返回负数
    		int _index = Arrays.binarySearch(arr1, arr1.length);
    		System.out.println(_index);
    		// Arrays.copyOf:按长度复制
    		// 多的补0/false/null
    		int[] b = Arrays.copyOf(arr1, 10);
    		System.out.println("copyOf:" +Arrays.toString(b));
    		// Arrays.fill:同值填充
    		Arrays.fill(arr1, -1);
    		System.out.println("fill:" +Arrays.toString(arr1));
    	}
    }
    

    补充

    a= Arrays.copyOf(a , 2 * a.length);这个用法通常用来增加数组的大小
    C++ 注释:Java 数组与 C++ 数组在堆栈上有很大不同, 但基本上与分配在堆(heap) 上
    的数组指针一样。也就是说,
    intD a = new int[100]; // Java
    不同于
    int a[100]; // C++
    而等同于
    int* a = new int[100]; // C++
    Java 中的 [ ] 运算符被预定义为检查数组边界,而且没有指针运算, 即不能通过 a 加
    1 得到数组的下一个元素。

    5.数组降序

    5.1.使用list集合以及reverse:先升序排列然后通过倒置,逆序

    Integer _arr[] = { 5, 3, 1, 2, 4 };
    Arrays.sort(_arr);
    List< Integer > asList = Arrays.asList(_arr);
    Collections.reverse(asList);//

    5.2使用Comparator接口,重写sort方法

    public static void 降序sort版() {
    		// 类,或包装类
    		int[] _arr = { 5, 3, 1, 2, 4 };
    		Arrays.sort(_arr, new Comparator<Integer>() {
    		@Override
    		public int compare(Integer o1, Integer o2)
    		{
    		return o2 - o1;
    		}
    		});
    }
    

    5.3使用Comparator接口,实现对字符串数组的排序

    	public static void charsort(String[] str) {		
    		//调用并且重写排序
    		Arrays.sort(str,new Comparator<String>() {
    			@Override
    			public int compare(String o1, String o2)
    				{
    					int o1len=o1.length();//获取长度
    					int o2len=o2.length();
    				for(int i=0;i<o1.length();i++) {//遍历每一个字符
    					char a=o1.charAt(i);				
    					if(a>'0'&&a<='9'||a>='a'&&a<='z'||a>='A'&&a<='Z'||a==' '||a=='_') {}
    					else//如果是中文就++
    						o1len++;				
    				}
    				for(int i=0;i<o2.length();i++) {
    					char a=o2.charAt(i);				
    					if(a>'0'&&a<='9'||a>='a'&&a<='z'||a>='A'&&a<='Z'||a==' '||a=='_') {}
    					else//如果是中文就++
    						o2len++;				
    				}
    					return  o1len-o2len;//按长度的升序排列
    				}
    			});
    		for (int i = 0; i < str.length; i++) {
    			System.out.println(str[i]);
    		}
    	}
    

    6.二维数组

    数组的初始化

    和一维数组一样也可以有c++的写法和java的写法,这里就不推荐用c++的写法了,直接来java的
    int[][] _arr21 = { { 1, 2 }, { 3, 4 } };
    int[][] _arr22 = new int[2][3];
    int[][] _arr23 = new int[2][];// 第二维度可以省略

    二维数组的遍历

    		//二维数组的遍历
    		int[][] a= {{2,3,4,5,5},{4,3,34,34,43},{67,422432,423,2,2},{6,3,2,1,19}};
    		for (int i = 0; i < a.length; i++) {
    			for (int j = 0; j < a[i].length; j++) {
    				System.out.println(a[i][j]);
    			}
    		}
    		
    		//foreach遍历
    		for(int[] arr:a) {
    			for(int arr1:arr) {
    				System.out.println(arr1);
    			}
    		}
    

    7.二维数组-矩阵乘法

    在这里插入图片描述
    代码:

    import java.util.Arrays;
    public class 二维矩阵相乘 {
    		public static void main(String[] args) {
    		int m = 2, p = 3, n = 2;
    		int[][] A = { { 1, 2, 3 }, { 4, 5, 6 } };
    		int[][] B = { { 1, 4 }, { 2, 5 }, { 3, 6 } };
    		int[][] C = new int[m][n];
    		for (int i = 0; i < m; i++) {
    				for (int j = 0; j < n; j++) {
    						for (int k = 0; k < p; k++) {
    						C[i][j] = C[i][j] + A[i][k]* B[k][j];
    						}
    				}
    		}
    		// ------------
    		for (int[] is : C) {
    		System.out.println(Arrays.toString(is));
    		}
    		}
    }
    
    展开全文
  • 降序遍历a数组,当有一个a[i]小于插入的数,则将数插入,将数组长度加1,并退出循环,(若不退出,之后的数全被替换) 输出时注意不将0输出 代码实现: #include&amp;lt;stdio.h&amp;gt; int main() { int a...
  • 输入N个学生学号,姓名,成绩,并按成绩降序排列,并输出 p指向结构体变量s1 , 则 s1.成员名,(*p).成员名,p->成员名 等价。 本题采用自定义函数较为合适 Author: emanlee, eman_lee@hotmail.com Dat.....
  • c语言sort函数:数的排列

    千次阅读 2017-04-04 20:20:57
    函数为sort(数组首地址,数组尾地址[,升序或降序]) 如果不声明是升序还是降序,默认为是升序。 (当然,这个函数不仅仅能对数进行排序,还可以对字母等数据类型进行排序,只不过需要说明,如对字母进行升序排序...
  • C语言排序之冒泡排序

    2020-04-04 22:19:36
    从键盘输入数字并降序排列 冒泡排序的意思是相邻的两个元素进行比较,如果前面的元素小于后面的元素,则把两个元素的位置调换;反之则不做调整。 ***首先***要考虑的是如何从键盘输入数字,并且把数字有序的存起来...
  • 二分查找的递归和非递归算法(C语言实现)

    千次阅读 多人点赞 2018-01-06 18:34:17
    二分查找的用途 二分查找又称折半查找,它用来解决“在一堆数中找出指定的数(也...至于是升序排列还是降序排列数组中是否存在相同的元素都不要紧。在本文的实验中,我们使数组递增排列,且数组中的元素互不相同。
  • 西南大学网络与继续教育学院课程考试试题卷 类别网教 专业...strlen函数 6从键盘上任意输入50个整数存放在a数组中找出a数组中所有偶数存放在数组b 一大作业题目 中并对b数组的值按降序排列 1.简述题 共30 分 要求 1
  • C语言 冒泡排序

    2019-11-24 09:38:51
    例子:将输入数,前一半按升序排列,后一半降序排列。 #include<stdio.h> int main() { int i,n,j,t,L[101]; // 定义一个相对大的数组 printf("请输入数组个数\n"); scanf("%d",&n); printf("请输入%d...
  • C语言正整数排序

    2020-03-29 12:53:57
    请编制函数jsSort(),其函数的功能是:要求按每个数的后三位的大小进行降序排列,然后取出满足此条件的前10个数依次存入数组b中,如果后三位的数值相等,则按原先的数值进行升序排列。后调用函数 WriteDat()把结果bb...
  • 文章目录第六章 数组6.1 筛选法求100以内的素数6.2 用选择法对10个整数排序6.3 求3阶矩阵的对角线元素之和6.4 在有序数组(升序)中插入一个数6.5 数组逆序排列其数值6.6 杨辉三角6.7 魔方阵6.8 鞍点6.9 降序数组的...
  • c语言源代码

    2014-07-25 09:52:19
    其中满足条件的个数作为函数jsSort 的返回值 同时把满足条件的数据存入结构数组bb中 再对结构数组bb中的数据按照每组数据的第二个数加第三个数之和的大小进行降序排列 排序后的结果仍重新存入结构数组bb中 最后调用...
  • 已知数组a中有m个按升序排列的元素,数组b中有n个按降序排列的元素,编程将a与b中的所有元素按降序存入数组c中。 输入 输入有两行,第一行首先是一个正整数m,然后是m个整数;第二行首先是一个正整数n,然后是n个...
  • 分析:这道题的核心程序是排序,将评委打的10个分数利用数组按增序(或降序)排列,计算数组中除了第一个和最后一个分数以外的数以外的数的平均分答案: #includedouble Aver(int p[],int count) //求出结果,p为整型...
  • 排序 问题描述: 对一个数组进行排序(升序或降序) 比较函数 如果返回值<0,表示被减数小于减数,不交换. ... //降序排列 //return (*b- *a); } 打印函数 void print(int* a,int size){ for (int i = 0;
  • 5. 编写程序STUDENT *Create(STUDENT studs[],int n)。  STUDENT是一个结构类型,包含姓名... 链表中结点按成绩降序排列,函数返回链表头指针。 分析:首先创建学生结构体,先把数据 排序好,然后再链接成链表
  • 五十一、将从键盘输入的一个数,插入到已按降序排列数组中,要求按原来的排序规律插入。 1 #include <stdio.h> 2 3 void main(void) 4 { 5 int i, j = 0, k, a[11] = {20, 18, 16, 14, 12, 10,...
  • c语言练习3

    2010-11-18 22:57:00
    3、编写一程序,把M×N矩阵a的元素逐列按降序排列。假设M、N不超过10。分别编写求一维数组元素值最大和元素值最小的函数,主函数中初始化一个二维数组a[10][10],调用定义的两函数输出每行、每列的最大值和...
  • 全国计算机等级考试三级C语言程序设计【注:三级除PC技术考汇编外,其它...就算变动也不过是把改一下个别数组名、把“升序排列”改为“降序排列”、把“从小到大”改为“从大到小”等,所以请大家消除疑虑,放心使用】
  • 待排序数组:被排列数组,比如整型数组a[100]。 排序数组长度:比如有20个被排序数字。 类型长度:可以用sizeof(a[0]) 表示。 排序方式:有升序排序和降序排序两种,以函数方式传递。 排序方式代码: int cmp(const...
  •  即将两个都升序(或降序排列的数据序列合并成一个仍按原序排列的序列。 上代码: #include #include #define m 6 #define n 4 int main() { int a[m]={-3,6,19,26,68,100} ,b[n]={8,10,12,22}; int i,j,k,...
  • 接着对signout进行降序排列,输出第一个id。便得到了开门和锁门的人对应的ID。 2、开始对signin和signout的处理是用字符串输入的,那这样我在写比较函数cmp时就要用字符串比较函数去比较字符串的大小,...
  • 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列),就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样,故名“冒泡排序”。 举例: (1)要排序数组:[10,1,35,61,89,36,55] ...
  • 1、看到这题会首先联想到姥姥讲《数据结构》课上提到的合并多项式加法的方法,因为这里指数都是降序排列,可以用两个数组存储指数和系数,然后比较指数大小,如果A的第一个指数小于B的第一个指数,则新多项式的第一...
  • c语言经典案例

    2014-10-30 08:06:57
    实例145 对数组进行升序和降序排序 185 实例146 设置组合键 187 实例147 获取当前日期与时间 188 实例148 获取当地日期与时间 189 实例149 获取格林尼治平时 190 实例150 设置系统日期 191 实例151 获取BIOS常规内存...
  • 思路 (以降序排列为例) 1.首先第一趟(从i=0)找出整个数组中(到i<n)的最大值,与a[0]交换(a[0]变成了最大值);《比较了n-1次 等价于n-i-1次》 2.然后第二趟(从i=1)找出剩下的数中的最大值,与a[1]交换;...
  • C语言------二分查找

    2020-10-22 15:54:11
    条件:数组为有序数组(升序或降序) 查找的思想:在有序数组中查找具体某个数,如果有,输出该数所对应的下标;如果没有,输出未找到. 具体思想:若为升序排列数组,取数组中间元素与待查找的数比较,若待查找的数小于中间...

空空如也

空空如也

1 2 3
收藏数 44
精华内容 17
关键字:

c语言数组降序排列

c语言 订阅