精华内容
下载资源
问答
  • 什么是数组:相同类型的变量的组合,是一种批量定义变量的方式 定义: 类型 数组名[数量]; int arr[5]; == int num1,num2,num3,num4,num5; 使用:数组名[下标]; 下标:从0开始,范围:0 ~ 数量-1 遍历:与for循环...

    数组:
    什么是数组:相同类型的变量的组合,是一种批量定义变量的方式
    定义: 类型 数组名[数量];
    int arr[5]; == int num1,num2,num3,num4,num5;

    使用:数组名[下标];
        下标:从0开始,范围:0 ~ 数量-1
    
    遍历:与for循环配合使用,使用循环变量 i 当做数组的下标
    
    初始化:类型 数组名[数量] = {1,2,3,4,5...};  
        1、数组与普通变量是一样默认值是随机,为安全也要对数组进行初始化
        2、这种初始化语法只能在定义数组时使用,而且不能整体赋值
        3、如果初始化数据过多,编译器会丢弃,并产生警告
        4、如果初始化数据不足,编译器则补0
        5、初始化数组时长度可以省略,编译器会自动统计数据的个数,然后告诉数组
            sizeof(arr)/sizeof(arr[0])   == 数组长度
    
    
    数组越界:
        为了程序的运行效率,不会检查数组的下标
        数组越界的后果:
            1、一切正常
            2、段错误
            3、脏数据
    

    二维数组:
    一维数组相当于把变量排成一排,通过编号访问。
    二维数组相当于把变量排成矩阵,通过行号和列号来访问。

    定义:类型 数组名[行数][列数];
        int arr[3][5];
        [0,0][0,1][0,2][0,3][0,4]
        [1,0][1,1][1,2][1,3][1,4]
        [2,0][2,1][2,2][2,3][2,4]
    使用:数组名[行下标][列下标]
            行下标: 0~行数-1
            列下标: 0~列数-1
    遍历:需要与双层for循环配合,外层循环负责遍历行,内层循环负责遍历列
    for(int i = 0;i < 3;i++)
    {   
        for(int j = 0;j < 5;j++)
        {   
            printf("%d ",arr[i][j]);    
        }   
        printf("\n");
    }  
    初始化:类型 数组名[行数][列数] = {{第一行},{第二行},{第三行}};
    

    变长数组:
    定义数组时使用变量作为数组的长度,在代码编译期间数组的长度是不确定,当执行到数组定义语句时,长度才能确定下来。
    一旦数组长度确定后,不能改变。

        优点:可以根据实际情况来确定数组的长度,能达到节约内存目的
        缺点:不可以初始化
    
    int n = 0;
    printf("请输入数组长度:");
    scanf("%d",&n);
    int arr[n];
    for(int i = 0;i <sizeof(arr)/sizeof(arr[0]);i++)
    {   
        printf("请输入数据: ");
        scanf("%d",&arr[i]);
    }   
    
    
    进制转换、原码反码补码
    函数
    类型限定符 const static volatile 
    指针
    字符串
    堆内存管理
    
    展开全文
  • 学习笔记5-C语言-数组

    2020-12-14 20:55:18
    数组: 什么是数组: 相同类型变量的组合,是一种批量定义变量的方式 定义: 类型 数组名[数组变量数量]; int arr[5];... 1、数组与普通变量一样,默认值是随机的,为了安全起见要对数组进行初始化

    数组:

    什么是数组:  
        相同类型变量的组合,是一种批量定义变量的方式
    定义:  
        类型 数组名[数组变量数量];
        int arr[5];
    使用:
        数组名[下标];
        arr[0];
        数组下标从零开始,范围:0~数量-1
    遍历:
        从头到尾过一遍,与for循环相配合,使用循环变量作为数组的下标
    初始化: 
        类型 数组名[数量] = {1,2,3,4,5...}
        1、数组与普通变量一样,默认值是随机的,为了安全起见要对数组进行初始化
        2、初始化数据过多时,编辑器会产生警告并且丢弃多余的数据
        3、初始化数据不足时,编辑器会自动补0
        4、初始化只能逐个赋值,不能整体赋值
        5、这种初始化的语法,只能在定义数组时使用
        6、初始化时,数组的长度可以省略,编译器会自动统计数据的个数,并告诉数组
            计算数组长度:
                sizeof(arr)/sizeof(arr[0])
        练习1:定义一个长度为十的数组,并初始化,计算出数组内的最大值,最小值,平均值
    
    #include<stdio.h>
    int main(int argc,const char* argv[])
    {
    	float arr[10]={};
    	int i;
    	float sum,MIN,MAX;
    	printf("输入10个数");
    	for(i=0;i<10;i++)
    	{
    		scanf("%f",&arr[i]);	
    	}
    	MAX=arr[0];
    	MIN=arr[0];
    	sum=arr[0];
    	for(i=1;i<10;i++)
    	{
    		if(MAX<arr[i])
    		{
    			MAX=arr[i];	
    		}	
    		if(MIN>arr[i])
    		{
    			MIN=arr[i];	
    		}
    		sum+=arr[i];
    	}
    	printf("%.1f %.1f %.1f",MAX,MIN,sum/10);
    	return 0;
    }
    
    	练习2:定义一个长度为十的数组,并初始化,进行升序排序
    
    #include<stdio.h>
     
    int main(int argc,const char* argv[])
    {
    	int a[10];
    	int i,j,c;
    	printf("输入10个数");
    	for(i=0;i<10;i++)
    	{
    		scanf("%d",&a[i]);	
    	}
    	for(i=0;i<10;i++)
    	{
    		for(j=i+1;j<10;j++)
    		{
    			if(a[i]>a[j])
    			{
    				c=a[i];
    				a[i]=a[j];
    				a[j]=c;
    			}
    		}
    	}
    	for(i=0;i<10;i++)
    	{
    		printf("%d ",a[i]);	
    	}
    	return 0;
    }
    

    数组越界:

    为了程序的运算效率不会检查数组下标
    数组越界结果:
        1、一切正常
        2、段错误
        3、脏数据
    
     练习3:定义一个长度10的数组,找出第二大的值,不允许排序
    
    #include<stdio.h>
     
    int main(int argc,const char* argv[])
    {
    	int a[10]={6,10,5,3,4,8,9,7,1,2};
    	int max=a[0]>a[1]?a[0]:a[1];
    	int secmax=a[0]>a[1]?a[1]:a[0];
    	for(int i=2;i<10;i++)
    	{
    		if(a[max]<=a[i])
    		{
    			secmax=max;	
    			max=i;
    		}
    		else if(a[secmax]<=a[i])
    		{
    			secmax=i;	
    		}
    	}
    	printf("%d %d",a[max],a[secmax]);
    }
    

    二维数组:

    一维数组当作把变量变成一排,通过编号来访问数组
    二维数组相当于把变量变成矩阵,通过行号列号访问
    
    定义:类型 数组名[行数][列数];
        int arr[3][5];
        [0,0][0,1][0,2][0,3][0,4]
        [1,0][1,1][1,2][1,3][1,4]
        [2,0][2,1][2,2][2,3][2,4]
    使用:数组名[行下标][列下标]
        行下标:0~行数-1
        列下标:0~列数-1
        arr[1][2]=100;
    遍历:一般需要与双层内循环配合,一般外层循环负责遍历行,内层循环遍历列
        for(int i =0;i<3;i++)
        {
            for(int j=0;j<5;j++)
            {
                printf("%d",a[i][j]);
            }
            printf("\n");
        }
    
    
    初始化: 类型 数组名[行数][列数]={{第一行数据},{第二行数据},{},...};
    
    练习4: 定义一个5*5的二维数组,找出最大值的坐标
    
    #include<stdio.h>
     
    int main(int argc,const char* argv[])
    {
    	int a[5][5]={
    		{9,8,5,7,6},
    		{2,5,8,7,4},
    		{3,69,8,5,4},
    		{3,5,8,7,4},
    		{3,6,98,4,2}
    		}	;
    	int maxi=0;
    	int maxj=0;
    	for(int i=0;i<5;i++)
    	{
    		for(int j=0;j<5;j++)
    		{
    			if(a[maxi][maxj]<a[i][j])
    			{
    				maxi=i;
    				maxj=j;
    			}
    		}
    	}
    	printf("(%d,%d)",maxi,maxj);
    }
    
    练习5:输入两个正整数m,n(1<=m<=61<=n<=6),输入数组arr[m][n]的每个元素,然后计算各元素之和,
    统计数组中非零元素个数,计算出所有元素的平均值,在统计大于平均值元素的个数。
    
    #include<stdio.h>
     
    int main(int argc,const char* argv[])
    {
    	int m,n;
    	printf("mn\n");
    	scanf("%d%d",&m,&n);
    	float a[m][n];
    	float sum=0;
    	printf("a\n");
    	int num0=0,num1=0;
    	for(int i=0;i<m;i++)
    	{
    		for(int j=0;j<n;j++)
    		{
    			scanf("%f",&a[i][j]);
    			sum += a[i][j];
    			if(a[i][j]!=0)
    			{
    				num0++;	
    			}
    		}
    	}
    	float avg=((float)sum)/(m*n);
    	for(int i=0;i<m;i++)
    	{
    		for(int j=0;j<n;j++)
    		{
    			if(a[i][j]>avg)
    			{
    				num1++;	
    			}
    		}
    	}
    	printf("和=%.1f 非零个数=%d 平均值=%.1f 大于平均值个数=%d",sum,num0,avg,num1);
    
    }
    
    练习6:定义一个5*5的二维数组并初始化,找出最小值下标,计算该坐标周边所有元素之和
    
    #include<stdio.h>
     
    int main(int argc,const char* argv[])
    {
    		
    	int a[5][5]={
    		{5,8,0,7,6},
    		{2,5,8,2,4},
    		{3,69,8,5,4},
    		{3,5,8,7,4},
    		{3,6,98,4,2}
    		}	;
    	int mini=0;
    	int minj=0;
    	for(int i=0;i<5;i++)
    	{
    		for(int j=0;j<5;j++)
    		{
    			if(a[mini][minj]>a[i][j])
    			{
    				mini=i;
    				minj=j;
    			}
    		}
    	}
    	int sum=0;
    	if(mini == 0 && minj ==0)
    	{
    		sum=a[0][1]+a[1][1]+a[1][0];	
    	}
    	else if(mini == 0 && minj ==4)
    	{
    		sum=a[0][3]+a[1][3]+a[1][4];	
    	}
    	else if(mini == 4 && minj ==4)
    	{
    		sum=a[4][3]+a[3][3]+a[3][4];	
    	}
    	else if(mini == 4 && minj ==0)
    	{
    		sum=a[4][1]+a[3][1]+a[3][0];	
    	}
    	else if(mini == 0)
    	{
    		sum=a[0][minj-1]+a[0][minj+1]+a[1][minj-1]+a[1][minj]+a[1][minj+1];	
    	}
    	else if(mini == 4)
    	{
    		sum=a[4][minj-1]+a[4][minj+1]+a[3][minj-1]+a[3][minj]+a[3][minj+1];	
    	}
    	else if(minj == 0)
    	{
    		sum=a[mini-1][0]+a[mini+1][0]+a[mini-1][1]+a[mini][1]+a[mini+1][1];	
    	}
    	else if(minj == 4)
    	{
    		sum=a[mini-1][4]+a[mini+1][4]+a[mini-1][3]+a[mini][3]+a[mini+1][3];	
    	}
    	else
    	{
    		sum=a[mini-1][minj-1]+a[mini-1][minj]+a[mini-1][minj+1]+a[mini][minj-1]+a[mini][minj+1]+a[mini+1][minj-1]+a[mini+1][minj]+a[mini+1][minj+1];	
    	}
    	printf("%d",sum);
    }
    

    变长数组:

    定义数组时使用变量作为数组的长度,在编译期间,数组长度是不确定的,当执行到该数组的定义语句时
    才确定它的长度,一旦确定后就无法更改长度直到程序结束。
    
    优点:可以根据实际情况来确定数组长度,达到节约内存的目的
    
    缺点:不能初始化
    
    练习7:显示N层杨辉三角
    
    #include<stdio.h>
     
    int main(int argc,const char* argv[])
    {
    	int N;
    	printf("N=");
    	scanf("%d",&N);
    	int a[N][N];
    	for(int i=0;i<N;i++)
    	{
    		for(int j=0;j<N;j++)
    		{
    			a[i][j]=0;	
    		}
    	}
    	a[0][0]=1;
    	for(int i=1;i<N;i++)
    	{
    		a[i][0]=1;
    		for(int j=1;j<N;j++)
    		{
    			a[i][j]=a[i-1][j-1]+a[i-1][j];	
    		}
    	}
    	for(int i=0;i<N;i++)
    	{
    		for(int j=0;j<N;j++)
    		{
    			a[i][j]>0 && printf("%d",a[i][j]);
    		}
    		printf("\n");
    	}
    
    
    }
    
    展开全文
  • C语言学习day4-数组

    2020-10-20 20:35:59
    什么是数组:相同类型的变量的组合,是一种批量定义变量的方式 定义: 类型 数组名[数量]; int arr[5]; == int num1,num2,num3,num4,num5; 使用:数组名[下标]; 下标:从0开始,范围:0 ~ 数量-1 遍历:与for循环...

    数组:
    什么是数组:相同类型的变量的组合,是一种批量定义变量的方式
    定义: 类型 数组名[数量];
    int arr[5]; == int num1,num2,num3,num4,num5;

    使用:数组名[下标];
        下标:从0开始,范围:0 ~ 数量-1
    
    遍历:与for循环配合使用,使用循环变量 i 当做数组的下标
    
    初始化:类型 数组名[数量] = {1,2,3,4,5...};  
        1、数组与普通变量是一样默认值是随机,为安全也要对数组进行初始化
        2、这种初始化语法只能在定义数组时使用,而且不能整体赋值
        3、如果初始化数据过多,编译器会丢弃,并产生警告
        4、如果初始化数据不足,编译器则补0
        5、初始化数组时长度可以省略,编译器会自动统计数据的个数,然后告诉数组
            sizeof(arr)/sizeof(arr[0])   == 数组长度
    
    练习1:定义一个长度为10的数组并初始化,计算出最大值,最小值,以及平均值。
    练习2:定义一个长度为10的数组并初始化,进行升序排序
        a b c d e
        0 1 2 3 4
    
    数组越界:
        为了程序的运行效率,不会检查数组的下标
        数组越界的后果:
            1、一切正常
            2、段错误
            3、脏数据
    
    练习3:定义一个长度为10的数组并初始化,找出数组中第二大的值。
    

    二维数组:
    一维数组相当于把变量排成一排,通过编号访问。
    二维数组相当于把变量排成矩阵,通过行号和列号来访问。

    定义:类型 数组名[行数][列数];
        int arr[3][5];
        [0,0][0,1][0,2][0,3][0,4]
        [1,0][1,1][1,2][1,3][1,4]
        [2,0][2,1][2,2][2,3][2,4]
    使用:数组名[行下标][列下标]
            行下标: 0~行数-1
            列下标: 0~列数-1
    遍历:需要与双层for循环配合,外层循环负责遍历行,内层循环负责遍历列
    for(int i = 0;i < 3;i++)
    {   
        for(int j = 0;j < 5;j++)
        {   
            printf("%d ",arr[i][j]);    
        }   
        printf("\n");
    }  
    初始化:类型 数组名[行数][列数] = {{第一行},{第二行},{第三行}};
    
    练习4:定义一个5*5二维数组,找出数组中的最大值的坐标,然后计算出来这个位置周围的和。
    

    变长数组:
    定义数组时使用变量作为数组的长度,在代码编译期间数组的长度是不确定,当执行到数组定义语句时,长度才能确定下来。
    一旦数组长度确定后,不能改变。

        优点:可以根据实际情况来确定数组的长度,能达到节约内存目的
        缺点:不可以初始化
    
    练习5:输入两个正整数m(1<=m<=6),n(1<=n<=6),然后输入数组arr[m][n]的各个元素的值,然后计算个元素的和,统计非零元素的个数,计算出所有元素的平均值,再计算元素的值大于平均值的元素个数。
    练习6:显示N层杨辉三角
    int n = 0;
    printf("请输入数组长度:");
    scanf("%d",&n);
    int arr[n];
    for(int i = 0;i <sizeof(arr)/sizeof(arr[0]);i++)
    {   
        printf("请输入数据: ");
        scanf("%d",&arr[i]);
    }   
    
    
    进制转换、原码反码补码
    函数
    类型限定符 const static volatile 
    指针
    字符串
    堆内存管理
    
    展开全文
  • 想法 定义一个数组装下所有的数字,然后随机配对,加入另一个数组; 思路 代码 反思

    在这里插入图片描述
    想法
    定义一个数组装下所有的数字,然后随机配对,加入另一个数组;

    思路
    (1)第一行第一个数字输入n,随后输入n个不同的数,此处采用一个简单的循环;
    (2)难点就是要将所有的组合数相加,这里我没有定义数组,而是直接使用了sum,两个简单循环,即一个数字作为十位数与其他数字相组合,其中要排除aa这种结构的出现,所以采用了if;
    (3)sum相加所有符合条件的组合数,并输出;

    代码

    #include<stdio.h>
    int main()
    {
    	int n;
    	scanf("%d",&n);
    	int i,a[10];
    	for(i=0; i<n; i++) scanf("%d",&a[i]);//input
    	int sum=0;
    	for(i=0; i<n; i++)
    	{for(int j=0;j<n;j++ )
    	if(i != j)
    		sum=sum+a[i]*10+a[j];
    	}printf("%d",sum);
    	return 0;
    }
    

    反思
    其实这道题看上去真的蛮简单的,但是还是耗费了不少时间,主要刚开始太慌张了,周日又要考试了,但是自己还是感觉什么也不会,现在就放松心态吧,认真的做每一道还有可能做出来的题就好了;fighting!!!
    你永远是奥特曼也打不倒的小怪兽!!!

    展开全文
  • 标准C语言day04

    2020-07-12 14:26:27
    什么是数组:变量的组合,是一种批量定义变量的方式。 定义:类型 数组名[数量]; int arr[5]; 使用:数组名[下标]; 下标:从零开始,范围:0~数量-1。 遍历:与for循环配合,使用循环变量i当作数组的下标。 初始化:...
  • C语言基础05

    2020-07-13 12:50:42
    什么是数组:变量的组合,是一种批量定义变量的方式。 定义:类型 数组名[数量]; int arr[5]; 使用:数组名[下标]; 下标:从零开始,范围:0~数量-1。 遍历:与for循环配合,使用循环变量i当作数组的下标。 初始化:...
  • 标准c语言03

    2020-10-20 20:19:56
    什么是数组:相同类型的变量的组合,是一种批量定义变量的方式 定义: 类型 数组名[数量]; int arr[5]; == int num1,num2,num3,num4,num5; 使用:数组名[下标]; 下标:从0开始,范围:0 ~ 数量-1 遍历:与for循环...
  • 标准C语言4

    2020-07-11 09:21:07
    1、数组与普通比那辆一样默认值时随机的,为了安全要对其进行初始化 2、这种初始化只能在定义数组时使用,而且必须使用常量初始化 3、初始化数据过多,编译器会丢弃并产生警告 4、初始化数据不够,编译器会补零 5、...
  • c语言经典案例

    2014-10-30 08:06:57
    实例146 设置组合键 187 实例147 获取当前日期与时间 188 实例148 获取当地日期与时间 189 实例149 获取格林尼治平时 190 实例150 设置系统日期 191 实例151 获取BIOS常规内存容量 193 实例152 读/写BIOS计时器 194 ...
  • 根号n分治排序的C语言实现: 算法课的这样一道题目 ...首先随机生成一个数组,把数组和一个临时存放数据的数组传入函数RadicalSort()并且传入数组的头位置和尾位置 RadicalSort()函数中在头位置小于尾位置...
  • 一、带高斯噪声的sin函数 b----振幅 f----频率 ...seed----随机种子 x----存放数据数组 n----数据长度 main.cpp #include <QCoreApplication> #include <math.h> #include ...
  • 数组类型 ?结构类型 ?联合类型 3.指针类型  指针是一种特殊的,同时又是具有重要作用的数据类型。其值用来表示某个量在内存储器中的地址。虽然指针变量的取值类似于整型量,但这是两个类型完全不同的量,因此不能...
  • 810.3 数组指针和指向数组的指针变量 141 10.3.1 指向数组元素的指针 142 10.3.2 通过指针引用数组元素 143 10.3.3 数组名作函数参数 146 10.3.4 指向多维数组的指针和指针变量 148 10.4 字符串的指针指向字符串的针...
  • 810.3 数组指针和指向数组的指针变量 141 10.3.1 指向数组元素的指针 142 10.3.2 通过指针引用数组元素 143 10.3.3 数组名作函数参数 146 10.3.4 指向多维数组的指针和指针变量 148 10.4 字符串的指针指向字符串的针...
  • (31) 算法一般都可以用哪几种控制结构组合而成(D) 注:P3 A. 循环、分支、递归 B. 顺序、循环、嵌套 C. 循环、递归、选择 D. 顺序、选择、循环 (32) 数据的存储结构是指(B) 注:P13,要牢记 A. 数据所占的存储空间量...
  • C语言通用范例开发金典.part2.rar

    热门讨论 2012-08-31 14:18:18
    1.1 数组和字符串 2 1.1.1 一维数组的倒置 2 范例1-1 一维数组的倒置 2 ∷相关函数:fun函数 1.1.2 一维数组应用 3 范例1-2 一维数组应用 3 1.1.3 一维数组的高级应用 5 范例1-3 一维数组的高级应用 5 1.1.4...
  • C语言通用范例开发金典.part1.rar

    热门讨论 2012-08-31 14:09:26
    1.1 数组和字符串 2 1.1.1 一维数组的倒置 2 范例1-1 一维数组的倒置 2 ∷相关函数:fun函数 1.1.2 一维数组应用 3 范例1-2 一维数组应用 3 1.1.3 一维数组的高级应用 5 范例1-3 一维数组的高级应用 5 1.1.4...
  • C++ Primer Plus 中文版 第4版 清晰版

    千次下载 热门讨论 2009-12-06 14:45:21
    5.1.6 组合赋值操作符 113 5.1.7 复合语句(语句块) 114 5.1.8 逗号操作符(或其他句法技巧) 115 5.2 关系表达式 117 5.2.1 可能犯的错误 118 5.2.2 字符串比较 119 5.3 while循环 121 5.3.1 for与...
  • 1.2.1 C语言 1.2.2 C语言编程原理 1.2.3 面向对象编程 1.2.4 C++和泛型编程 1.2.5 C++的起源 1.3 可移植性和标准 1.3.1 C++的发展 1.3.2 本书遵循的C++标准 1.4 程序创建的技巧 1.4.1 创建源代码文件 ...
  • 算法笔记 胡凡 曾磊

    2018-10-16 17:38:13
    147 4.7.3 随机选择算法 149 第5章 入门篇(3)——数学问题 152 5.1 简单数学 152 5.2 最大公约数与最小公倍数 154 5.2.1 最大公约数 154 5.2.2 最小公倍数 156 5.3 分数的四则运算 156 5.3.1 分数的表示和化简 157...
  • 4.7.3 随机选择算法 149 第5章 入门篇(3)——数学问题 152 5.1 简单数学 152 5.2 最大公约数与最小公倍数 154 5.2.1 最大公约数 154 5.2.2 最小公倍数 156 5.3 分数的四则运算 156 5.3.1 分数的表示和化简 157 ...
  • 319 理解随机流函数 320 理解width()、precision0和fill() 321 理解I/O操纵器 322 创建自己的插入符 323 创建自己的提取符 第二十七章 C++数组和指针 324 理解对象指针 325 理解类指针 326 this指针 327 使用malloc...
  • 319 理解随机流函数 320 理解width()、precision0和fill() 321 理解I/O操纵器 322 创建自己的插入符 323 创建自己的提取符 第二十七章 C++数组和指针 324 理解对象指针 325 理解类指针 326 this指针 327 使用malloc...
  • 319 理解随机流函数 320 理解width()、precision0和fill() 321 理解I/O操纵器 322 创建自己的插入符 323 创建自己的提取符 第二十七章 C++数组和指针 324 理解对象指针 325 理解类指针 326 this指针 327 使用malloc...
  • 319 理解随机流函数 320 理解width()、precision0和fill() 321 理解I/O操纵器 322 创建自己的插入符 323 创建自己的提取符 第二十七章 C++数组和指针 324 理解对象指针 325 理解类指针 326 this指针 327 使用malloc...

空空如也

空空如也

1 2 3
收藏数 56
精华内容 22
关键字:

c语言数组随机组合

c语言 订阅