定义二维数组int&a[2][3]，从键盘输入数组元素，最后输出各元素。
14-11-28 &匿名提问C++数组的概念,一维数组，二维数组
概括地说：数组是有序数据的集合。要寻找一个数组中的某一个元素必须给出两个要素，即数组名和下标。数组名和下标惟一地标识一个数组中的一个元素。
数组是有类型属性的。同一数组中的每一个元素都必须属于同一数据类型。一个数组在内存中占一片连续的存储单元。如果有一个整型数组a，假设数组的起始地址为2000，则该数组在内存中的存储情况如图5.1所示。
引入数组就不需要在程序中定义大量的变量，大大减少程序中变量的数量，使程序精炼，而且数组含义清楚，使用方便，明确地反映了数据间的联系。许多好的算法都与数组有关。熟练地利用数组，可以大大地提高编程和解题的效率，加强了程序的可读性。
C++用方括号来表示下标，如用s[1]，s[2]，s[3] 分别代表s1，s2，s3。&
定义一维数组
定义一维数组的一般格式为：
& & 类型标识符& 数组名[常量表达式];
& & int a[10];
它表示数组名为a，此数组为整型，有10个元素。
关于一维数组的几点说明：
1)&数组名定名规则和变量名相同，遵循标识符定名规则。
2) 用方括号括起来的常量表达式表示下标值，如下面的写法是合法的：
& & int a[10];
& & int a[2*5];
& & int a[n*2]; //假设前面已定义了n为常变量
3) 常量表达式的值表示元素的个数，即数组长度。例如，在&int a[10];&中，10表示a数组有10个元素，下标从0开始，这10个元素是： a[0]，a[1]，a[2]，a[3]，a[4]，a[5]，a[6]，a[7]， a[8]，a[9]。注意最后一个元素是a[9]而不是a[10]。
4) 常量表达式中可以包括常量、常变量和符号常量，但不能包含变量。也就是说，C++不允许对数组的大小作动态定义，即数组的大小不依赖于程序运行过程中变量的值。例如，下面这样定义数组是不行的：
& & cin&&n;& //输入a数组的长度
& & int a[n]; //企图根据n的值决定数组的长度
如果把第1，2行改为下面一行就合法了：
& & const int n=5;
引用一维数组的元素
数组必须先定义，然后使用。只能逐个引用数组元素的值而不能一次引用整个数组中的全部元素的值。
数组元素的表示形式为：
& & 数组名[下标]
下标可以是整型常量或整型表达式。例如：
& & a[0]= a[5]+ a[7]- a[2*3]
【例5.1】数组元素的引用。
#include &iostream&
int main( )
int i, a[10];
for (i=0;i&=9;i++)
for (i=9;i&=0;i--)
cout&&a[i]&&& &;
运行结果如下：
9 8 7 6 5 4 3 2 1 0
程序使a[0]~a[9]的值为0~9，然后按逆序输出。
一维数组的初始化
1) 在定义数组时分别对数组元素赋予初值。例如：
&&& int a[10]={0,1,2,3,4,5,6,7,8,9};
2) 可以只给一部分元素赋值。例如：
&&& int a[10]={0,1,2,3,4};
3) 如果想使一个数组中全部元素值为1，可以写成：
&&& int a[10]={1,1,1,1,1,1,1,1,1,1};
& & int a[10]={1*10};
不能给数组整体赋初值。
4) 在对全部数组元素赋初值时，可以不指定数组长度。例如：
&&& int a[5]={1,2,3,4,5};
& & int a[]={1,2,3,4,5};
一维数组程序举例
【例5.2】用数组来处理求Fibonacci数列问题。
可以用20个元素代表数列中的20个数，从第3个数开始，可以直接用表达式f[i]=f[i-2]+f[i-1]求出各数。程序如下：
#include &iostream&
#include &iomanip&
int main( )
int f[20]={1,1}; //f[0]=1,f[1]=1
for(i=2;i&20;i++)
f[i]=f[i-2]+f[i-1]; //在i的值为2时,f[2]=f[0]+f[1],依此类推
for(i=0;i&20;i++) //此循环的作用是输出20个数
if(i%5==0) cout&& //控制换行,每行输出5个数据
cout&&setw(8)&&f[i]; //每个数据输出时占8列宽度
cout&& //最后执行一次换行
运行结果如下：
【例5.3】编写程序，用起泡法对10个数排序（按由小到大顺序）。
起泡法的思路是：将相邻两个数比较，将小的调到前头。见图5.2。然后进行第2趟比较，对余下的前面5个数按上法进行比较，见图5.3。
可以推知，如果有n个数，则要进行n-1趟比较(和交换)。在第1趟中要进行n-1次两两比较，在第j趟中要进行n-j次两两比较。
根据以上思路写出程序，今设n=10，本例定义数组长度为11，a[0]不用，只用a[1]~a[10]，以符合人们的习惯。从前面的叙述可知，应该进行9趟比较和交换。
#include &iostream&
int main( )
int a[11];
cout&&&input 10 numbers ：&&&
for (i=1;i&11;i++)
//输入a[1]~a[10]
cin&&a[i];
for (j=1;j&=9;j++) //共进行9趟比较
for(i=1;i&=10-j;i++)//在每趟中要进行(10-j)次两两比较
if (a[i]&a[i+1]) //如果前面的数大于后面的数
t=a[i];a[i]=a[i+1];a[i+1]=t;
}//交换两个数的位置, 使小数上浮
cout&&&the sorted numbers ：&&&
for(i=1;i&11;i++) //输出10个数
cout&&a[i]&&& &;
运行情况如下：
input 10 numbers：
3 5 9 11 33 6 -9 -76 100 123↙
the sorted numbers：
-76 -9 3 5 6 9 11 33 100 123&
具有两个下标的数组称为二维数组。有些数据要依赖于两个因素才能惟一地确定，例如有3个学生，每个学生有4门课的成绩，显然，成绩数据是一个二维表，如书中表5.1所示。
表5.1 学生成绩数据表
想表示第3个学生第4门课的成绩，就需要指出学生的序号和课程的序号两个因素，在数学上以S3,4表示。在C++中以s[3][4]表示，它代表数据73。
定义二维数组
定义二维数组的一般形式为：
& & 类型标识符 数组名[常量表达式][常量表达式];
& & float a[3][4], b[5][10];
定义a为3&4(3行4列)的单精度数组，b为5&10(5行10列)的单精度数组。注意不能写成&float a[3,4], b[5,10];&。C++对二维数组采用这样的定义方式，使我们可以把二维数组看作是一种特殊的一维数组：它的元素又是一个一维数组。例如，可以把a看作是一个一维数组，它有3个元素：a[0]，a[1]，a[2]，每个元素又是一个包含4个元素的一维数组，见图5.4。a[0]，a[1]，a[2]是3个一维数组的名字。
上面定义的二维数组可以理解为定义了3个一维数组，即相当于：
& & float a[0][4], a[1][4], a[2][4];
此处把a[0]，a[1]，a[2]作一维数组名。C++的这种处理方法在数组初始化和用指针表示时显得很方便，这在以后会体会到。
C++中，二维数组中元素排列的顺序是：按行存放，即在内存中先顺序存放第一行的元素，再存放第二行的元素。图5.5表示对a[3][4]数组存放的顺序。
C++允许使用多维数组。有了二维数组的基础，再掌握多维数组是不困难的。例如，定义三维数组的方法是：
& & float a[2][3][4];
定义float型三维数组a，它有2&3&4=24个元素。多维数组元素在内存中的排列顺序：第一维的下标变化最慢，最右边的下标变化最快。例如，上述三维数组的元素排列顺序为：
a[0][0][0]&a[0][0][1]&a[0][0][2]&a[0][0][3]&a[0][1][0]&a[0][1][1]&a[0][1][2]&a[0][1][3]&a[0][2][0]&a[0][2][1]&a[0][2][2]&a[0][2][3]&a[1][0][0]&a[1][0][1]&a[1][0][2]&a[1][0][3]&a[1][1][0]&a[1][1][1]&a[1][1][2]&a[1][1][3]&a[1][2][0]&a[1][2][1]&a[1][2][2]&a[1][2][3]
二维数组的引用
二维数组的元素的表示形式为：
& & 数组名 [下标][下标]
& & a[2][3]
下标可以是整型表达式，如a[2-1][2*2-1]。不要写成a[2,3]，a[2-1,2*2-1]形式。
数组元素是左值，可以出现在表达式中，也可以被赋值，例如：
& & b[1][2]=a[2][3]/2;
在使用数组元素时，应该注意下标值应在已定义的数组大小的范围内。常出现的错误是：
& & int a[3][4];& //定义3行4列的数组
& & a[3][4]=15; //引用a[3][4]元素
定义a为3&4的数组，它可用的行下标值最大为2，列坐标值最大为3。最多可以用到a[2][3]，a[3][4]就超过了数组的范围。
请严格区分在定义数组时用的a[3][4]和引用元素时的a[3][4]的区别。前者a[3][4]用来定义数组的维数和各维的大小，后者a[3][4]中的3和4是下标值，a[3][4]代表某一个元素。
二维数组的初始化
可以用下面的方法对二维数组初始化：
1)&分行给二维数组赋初值。如
& & &int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
这种赋初值方法比较直观，把第1个花括号内的数据赋给第1行的元素，第2个花括号内的数据赋给第2行的元素&&即按行赋初值。
2) 可以将所有数据写在一个花括号内，按数组排列的顺序对各元素赋初值。如
&&& int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
效果与前相同。但以第1种方法为好，一行对一行，界限清楚。用第2种方法如果数据多，写成一大片，容易遗漏，也不易检查。
3) 可以对部分元素赋初值。如：
&&& int a[3][4]={{1},{5},{9}};
它的作用是只对各行第1列的元素赋初值，其余元素值自动置为0。赋初值后数组各元素为：
1& 0& 0& 0
5& 0& 0& 0
9& 0& 0& 0
也可以对各行中的某一元素赋初值：
& &&int a[3][4]={{1},{0,6},{0,0,11}};
初始化后的数组元素如下：
1& 0& 0& 0
0& 6& 0& 0
0& 0 11& 0
这种方法对非0元素少时比较方便，不必将所有的0都写出来，只需输入少量数据。也可以只对某几行元素赋初值：
& & int a[3][4]={{1},{5,6}};
数组元素为：
1& 0& 0& 0
5& 6& 0& 0
0& 0& 0& 0
第3行不赋初值。也可以对第2行不赋初值：
& & int a[3][4]={{1},{},{9}};
4) 如果对全部元素都赋初值（即提供全部初始数据），则定义数组时对第一维的长度可以不指定，但第二维的长度不能省。如：
&&& int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
& & int a[][4]={1,2,3,4,5,6,7,8,9,10,11,12};
系统会根据数据总个数分配存储空间，一共12个数据，每行4列，当然可确定为3行。
在定义时也可以只对部分元素赋初值而省略第一维的长度，但应分行赋初值。如
&&& int a[][4]={{0,0,3},{},{0,10}};
这样的写法，能通知编译系统： 数组共有3行。数组各元素为：
0& 0& 3& 0
0& 0& 0& 0
C++在定义数组和表示数组元素时采用a[][]这种两个方括号的方式，对数组初始化时十分有用，它使概念清楚，使用方便，不易出错。
二维数组程序举例
【例5.4】将一个二维数组行和列元素互换，存到另一个二维数组中。例如：
程序如下：
复制纯文本新窗口
#include &iostream&
using namespace std;
int main( )
int a[2][3]={{1,2,3},{4,5,6}};
int b[3][2],i,j;
cout&&&array a：&&&endl;
for (i=0;i&=1;i++)
for (j=0;j&=2;j++)
cout&&a[i][j]&&& &;
b[j][i]=a[i][j];
cout&&endl;
cout&&&array b：&&&endl;
for (i=0;i&=2;i++)
for(j=0;j&=1;j++)
cout&&b[i][j]&&& &;
cout&&endl;
#include &iostream&
int main( )
int a[2][3]={{1,2,3},{4,5,6}};
int b[3][2],i,j;
cout&&&array a：&&&
for (i=0;i&=1;i++)
for (j=0;j&=2;j++)
cout&&a[i][j]&&& &;
b[j][i]=a[i][j];
cout&&&array b：&&&
for (i=0;i&=2;i++)
for(j=0;j&=1;j++)
cout&&b[i][j]&&& &;
运行结果如下：
【例5.5】有一个3&4的矩阵，要求编程序求出其中值最大的那个元素的值，以及其所在的行号和列号。
开始时把a[0][0]的值赋给变量max，然后让下一个元素与它比较，将二者中值大者保存在max中，然后再让下一个元素与新的max比，直到最后一个元素比完为止。max最后的值就是数组所有元素中的最大值。程序如下：
复制纯文本新窗口
#include &iostream&
using namespace std;
int main( )
int i,j,row=0,colum=0,max;
int a[3][4]={{5,12,23,56},{19,28,37,46},{-12,-34,6,8}};
max=a[0][0];
for (i=0;i&=2;i++)
for (j=0;j&=3;j++)
if (a[i][j]&max)
max=a[i][j];
cout&&&max=&&&max&&&,row=&&&row&&&,colum=&&&colum&&endl;
#include &iostream&
int main( )
int i,j,row=0,colum=0,
int a[3][4]={{5,12,23,56},{19,28,37,46},{-12,-34,6,8}};
max=a[0][0];//使max开始时取a[0][0]的值
for (i=0;i&=2;i++)//从第0行~第2行
for (j=0;j&=3;j++) //从第0列~第3列
if (a[i][j]&max) //如果某元素大于max
max=a[i][j];
//max将取该元素的值
//记下该元素的行号i
colum=j;//记下该元素的列号j
cout&&&max=&&&max&&&,row=&&&row&&&,colum=&&&colum&&
输出结果为
max=56，row=0，colum=3&
相关内容：
编程爱好者
WEB编程开发c 语言的例题 数组的 经典题 - 推酷
c 语言的例题 数组的 经典题
数组的应用：
1.依次按照下面要求完成操作：
声明一个包含6个元素的int数组chuck，并将它初始化为从2开始的连续6个偶数。
编写语句，将chuck数组的第一个元素和最后一个元素的和赋值给变量even，并将even输出。
编写语句，显示chuck数组中第3个元素的值。
编写语句，将chuck数组中第5个元素的值改为100。
编写语句，依次显示chuck数组中所有的元素，元素间用逗号隔开。
倒序输出chuck数组中所有的元素。
另外定义一个6个元素的int数组dipsea(要求在定义时所有元素初始化为0)，将chuck数组的内容赋值给
dipsea数组，然后显示dipsea数组所有元素的值，元素间用逗号隔开。
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int chuck[6] = { 2, 4, 6, 8, 10, 12 };
int i = 0;
chuck[4] = 100;
printf(&6个偶数元素为：\n&);
for (i = 0; i & 6; i++) {
printf(&%d,&, chuck[i]);
printf(&\n&);
printf(&第一个元素和最后一个元素的和为：\n&);
even = chuck[0] + chuck[5];
printf(&%d\n&, even);
printf(&chuck数组中第3个元素的值为：\n&);
printf(&%d\n&, chuck[2]);
printf(&chuck数组中第5个元素的值为：\n&);
printf(&%d\n&, chuck[4]);
printf(&倒序输出为：\n&);
for (i = 5; i &= 0; i--) {
printf(&%d &, chuck[i]);
printf(&\n&);
int dipsea[6] = { 0, 0, 0, 0, 0, 0 };
printf(&dipsea数组所有元素的值为：\n&);
for (i = 0; i & 6; i++) {
dipsea[i] = chuck[i];
printf(&%d &, dipsea[i]);
return EXIT_SUCCESS;
2.编写一个程序，从键盘上接收10个整数，将它们保存到一个数组里。在输入完成后输出用户刚刚输入的
10个整数。
从键盘上再接收一个整数，将它保存到int变量number里。
从刚才第一次接收的10个整数中，查找是否有整数number，如果有则输出它在数组中的位置，否则输出没
有找到（没有找到是指数组中没有一个元素的值与number值相等，则输出没有找到）。
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int arr[10];
printf(&请输入10个整数：&);
fflush(stdout);
for(i=0;i&10;i++){
scanf(&%d&,&arr[i]);
printf(&数组元素为：\n&);
for(i=0;i&10;i++){
printf(&%d &,arr[i]);
printf(&\n&);
printf(&请在输入一个整数:\n&);
fflush(stdout);
scanf(&%d&, &number);
for (i = 0; i & 10; i++)
if (arr[i] == number)
if (i &= 10){
printf(&没有找到!\n&);
printf(&%d在数组中得位置是：arr[%d]!&, arr[i], i);
return EXIT_SUCCESS;
3.定义一个数组days，将其初始化为今年每月的天数，编写一段程序，将每月的天数打印出来。打印形式
如下:Month 1 has 31days.
#include &stdio.h&
#include &stdlib.h&
#define MONTHS 12
int main(void) {
int days[MONTHS] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
for (i = 0; i & MONTHS; i++) {
printf(&MONTH %d has %d days.\n&, i + 1, days[i]);
return EXIT_SUCCESS;}
4.编写一段程序，要求定义一个含有5个元素的数组，实现数组接收键盘输入的数字，输入完毕后打印数组
元素，并比较得出数组中元素的最大值和最小值，并输出。
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int arr[5];
int i,max,
printf(&请输入五个整数：&);
fflush(stdout);
for(i=0;i&5;i++){
scanf(&%d&,&arr[i]);
printf(&数组元素为：\n&);
for(i=0;i&5;i++){
printf(&%d &,arr[i]);
max=min=arr[0];
for(i=0;i&=4;i++){
if(max&arr[i]){
max=arr[i];
}else if(min&arr[i]){
min=arr[i];
printf(&\n&);
printf(&最大值为：%d\n最小值为：%d\n&,max,min);
return EXIT_SUCCESS;
5.定义一个由整数组成的数组，求出其中奇数的个数和偶数的个数，并打印。
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int arr[]={1,2,3,4,5,6,7};
int i,js=0,os=0;
int len =sizeof(arr)/sizeof(int);
printf(&数组元素为：\n&);
for(i=0;i&i++){
if(arr[i]%2==0){
printf(&%d &,arr[i]);
printf(&\n&);
printf(&偶数个数为：%d\n奇数个数为：%d&,os,js);
return EXIT_SUCCESS;}
6.定义一个int型的一维数组，包含10个元素，分别赋值为1~10， 然后将数组中的元素都向前移一个位置
，即a[0]=a[1],a[1]=a[2],…最后一个元素的值是原来第一个元素的值，然后输出这个数组。
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int arr[]={1,2,3,4,5,6,7,8,9,10};
printf(&原数组为：\n&);
for(i=0;i&10;i++){
printf(&%d &,arr[i]);
printf(&\n&);
temp=arr[0];
for(i=0;i&9;i++){
arr[i]=arr[i+1];
printf(&向前移动后的数组为：\n&);
for(i=0;i&10;i++){
printf(&%d &,arr[i]);
return EXIT_SUCCESS;}
7.有一个3行4列的数组，编写一段程序，求出其中的最大值，以及最大值所在的行号和列号。
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
int i,j,c,d,
max=a[0][0];
//循环行数
for(i=0;i&=2;i++){
//循环列数
for(j=0;j&=3;j++){
if(max&=a[i][j]){
max=a[i][j];
printf(&最大数为：%d\n行号为：%d\n列号为：%d&,max,c+1,d+1);//下标从0开始
return EXIT_SUCCESS;
8.定义一个包含有5个元素的int数组，并且初始化为0；
从键盘上接收5个整数，依次保存到int数组中。
要求你想办法，把数组的元素值倒序过来存储。
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int arr[5]={0,0,0,0,0};
printf(&请输入五个整数：&);
fflush(stdout);
for(i=0;i&5;i++){
scanf(&%d&,&arr[i]);
printf(&五个整数逆序输出为：\n&);
for(i=4;i&=0;i--){
printf(&%d &,arr[i]);
return EXIT_SUCCESS;
打印一个十行的杨辉三角，打印效果如图所示：
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int i, j, a[11][11];
for (i = 1; i & 11; i++) {/*for循环i的范围从1到10*/
a[i][i] = 1;/*对角线元素全为1*/
a[i][1] = 1; /*每行第一列元素全为1*/&}
printf(&打印图形如下：\n&);
for (i = 3; i & 11; i++)/*for循环范围从第3行开始到第10行*/
for (j = 2; j &= i - 1; j++)/*for循环范围从第2列开始到该行行数减一列为止*/
a[i][j] = a[i - 1][j - 1] + a[i - 1][j];/*第i行j列等于第i-1行j-1列的
值加上第i-1行j列的值*/
for (i = 1; i & 11; i++) {
for (j = 1; j &= j++)
printf(&%-5d&, a[i][j]);/*通过上面两次for循环将二维数组a中元素输出*/
printf(&\n&);/*每输出完一行进行一次换行*/
return EXIT_SUCCESS;}
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致c语言一维数组练习题-海达范文网
c语言一维数组练习题
相关热词搜索：
篇一：C语言数组试题 第4章 数组 4.1内容概述 本章主要介绍了数值数组和字符数组的定义、初始化、元素引用和数组数据的输入与输出，字符数组实现字符串、字符串函数的实现与调用。指针数组与数组指针定义、元素引用。利用一维数组实现如挑数、排序、求和等实际应用问题。利用二维数组实现矩阵的应用问题。利用字符数组实现字符串的各种操作。本章知识结构如图4.1所示。 定义初始化
数组元素输入和输出 定义 初始化
数组字符数组元素引用 数组元素输入和输出
定义指针数组初始化
应用 图4.1 第4章知识结构图 考核要求：掌握一维数组、二维数组、字符数组和指针数组的定义和初始化；掌握数组元素存储地址计算；掌握数组元素的下标法、指针法引用；掌握字符数组与字符串的区别与联系；掌握有关字符串处理函数的使用方法；能利用一维数组、二维数组解决向量、矩阵等实际应用问题。 重点难点：本章的重点是一维数组、二维数组和字符数组的定义、初始化、元素引用，字符串处理函数的使用。本章的难点是字符串与字符数组的区别，指针数组和数组元素的指针法引用。 核心考点：数组的定义、初始化和数组元素的引用方法，一维数组、二维数组和字符数组的实际应用，字符串的处理方法。 4.2 典型题解析 【例4.1】以下对一维数组a的定义中正确的是（ ）。 A. char a(10);
B. inta[0..100]; C. int
a[5];D. int
k=10;int a[k]; 解析：一维数组定义的一般形式为： 类型标识符数组名[常量表达式] 其中，常量表达式可以是任意类型，一般为算术表达式，其值表示数组元素的个数，即数组长度。 答案：C 【例4.2】以下对一维数组的定义中不正确的是（ ）。 A. double x[5]={2.0,4.0,6.0,8.0,10.0};B. int
y[5]={0,1,3,5,7,9}; C. char ch1[ ]={'1', '2', '3', '4', '5'}; D. char
ch2[ ]={'\x10', '\xa', '\x8'}; 解析：可以对一维数组的全部元素或部分元素赋初值。在对全部数组元素初始化时，数组长度可以省略。若数组长度没有省略，则初始化列表中值的个数不能超过数组的长度。 答案:B 【例4.3】以下对二维数组的定义中正确的是（ ）。 A．int a[4][]={1，2，3，4，5，6}; B. int
a[][3]; C．int a[][3]= {1，2，3，4，5，6};D. int a[][]＝{{1,2,3},{4,5,6}}; 解析：定义二维数组时，若按一维格式初始化，则第一维的长度可以省略，此时，系统可根据初始化列表中值的个数及第二维的长度计算出省略的第一维长度，但无论如何，第二维的长度不能省略。没有初始化时，每一维的长度都不能省略。 答案：C 【例4.4】假定一个int型变量占用两个字节，若有定义：int x[10]={0,2,4}; 则数组x在内存中所占字节数是（ ）。 A. 3
B. 6 C. 10
D. 20 解析：一维数组在内存中所占的字节数为：数组长度×sizeof(元素类型)。 答案：D 【例4.5】以下程序的输出结果是（ ）。 main() { int a[4][4]={{1,3,5},{2,4,6},{3,5,7}}; printf(&%d%d%d%d\n&,a[0][3],a[1][2],a[2][1],a[3][0]); } A. 0650B. 1470C. 5430 D. 输出值不定 解析：定义的数组a为4行4列，且前三行三列元素已初始化，根据C语法规定，未初始化的元素值为0。 答案：A 【例4.6】以下程序的输出结果是（ ）。 main() { int m[][3]={1,4,7,2,5,8,3,6,9};int i,j,k=2; for(i=0;i&3;i++){ printf(&%d &,m[k][i]);} } A. 4 5 6 B. 2 5 8 C. 3 6 9D. 7 8 9 解析：根据初始化列表中值的个数和第二维的长度，可求得第一维长度为3。第一行的元素值依次为1，4，7；第二行元素值依次为2，5，8；第三行元素值依次为3，6，9。循环执行三次，依次输出行标为2的三个元素，即第三行的3个元素。 答案：C 【例4.7】以下程序的输出结果是（ ）。 main() { int b[3][3]={0,1,2,0,1,2,0,1,2},i,j,t=0; for(i=0;i&3;i++) for(j=i;j&=i;j++) t=t+b[i][b[j][j]]; printf(&%d\n&,t);} A. 3
C. 1 D. 9 解析：程序中，引用的b数组元素的行下标为循环变量i，列下标为数组元素b[j][j]。外层循环共进行3次，对于每次外循环，内层循环只执行一次（即j=i），所以变量t 的值为元素b[0][b[0][0]]、b[1][b[1][1]]、b[2][b[2][2]]的和。由于数组元素b[0][0]、b[1][1]、b[2][2]的值分别为0、1、2，所以t的值为：0+0+1+2=3。 答案：A 【例4.8】若有定义：int a[2][4];，则引用数组元素正确的是（ ）。 A. a[0][3] B. a[0][4] C. a[2][2]D. a[2][2+1] 解析：引用二维数组元素时，行下标范围为0～行数-1，列下标范围为0～列数-1。 答案：A 【例4.9】若有定义：int aa[8];，则不能代表数组元素aa[1]地址的是（） 。 A. &aa[0]+1
B. &aa[1]C. &aa[0]++D. aa+1 解析： &aa[1]、&aa[0]+1和aa+1都是数组元素aa[1]的地址。由于&aa[0]是地址值常量，不能进行自加、自减运算，所以选项C不能代表aa[1]地址。 答案：C 【例4.10】下列程序执行后的输出结果是（ ） 。 main() { int a[3][3], *p,i;p=&a[0][0]; for(i=0;i&9;i++) p[i]=i+1; printf(&%d \n&,a[1][2]); } A. 3B. 6C. 9D. 随机数 解析：二维数组的物理存储结构为一维，即按行序顺序存储在连续存储空间中。 本题中，p为指向数组元素的指针变量，初始时，p指向a[0][0]。通过指针p实现对对二维数组元素按行依次赋值。a[1][2]即p[5]，其值6。 答案：B 【例4.11】下列程序的输出结果是( )。 main() { char a[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5; printf(&%d&,*--p); } A. 运行出错B. a[4]的地址 C. 5D. 3 解析：初始时，p指向a[5]。由于单目运算符的结合方向为右结合，所以，*--p等价于*（--p），即先执行--p，p指向a[4]，再输出a[4]的值（5）。 答案：C 【例4.12】若有如下定义，则b的值是（ ）。 int a[10]={1,2,3,4,5,6,7,8,9,10},*p=&a[3],b=p[5]; A. 5 B. 6 C. 8 D. 9 解析：p指向a[3]，即p=a+3；b=p[5]，即b=*(p+5)。因此，b=*(a+8)=a[8]=9。
答案：D 【例4.13】若二维数组y有m列，则排在y[i][j]前的元素个数为（ ） A.j*m+i B.i*m+j C.i*m+j-1 D.i*m+j+1 解析：C语言中的二维数组按行存储。行标为i的元素前共有i行元素，元素个数为i*m，每行列标为j的元素前共有j个元素。因此，y[i][j]前的元素个数为i*m+j。 答案：B 【例4.14】若有定义：char a[10],*b=a;，则不能给数组a输入字符串”This is a book”的语句是( )。 A. gets(a)B. scanf(&%s&,a)
C. gets(&a[0]); D. gets(b) ; 解析： gets为字符串输入函数，调用该函数时需给出字符串的存储地址，以回车作为字符串输入的结束，并将回车符转换成为’\0’。而scanf函数则以回车、空格或跳格作为串输入结束，因此scanf不能输入有空格的字符串。 答案：B 【例4.15】以下程序执行后的输出结果是（ ）。 A. 2B. 3C. 4 D. 5 #include &string.h& main( ) { char *p[10]={ &abc&,&aabdfg&,&dcdbe&,&abbd&,&cd&}; printf(&%d\n&,strlen(p[4])); } 解析：定义了一个含有10个元素的字符指针数组p，并对前5个元素初始化，其中p[4]指向字符串&cd&，其串长为2。 答案：A 【例4.16】若定义一个名为s且初值为&123&的字符数组，则下列定义错误的是（ ）。 A．char s[]={’1'，'2'，'3'，'\0 '};B．char s[]={&123&}; C．char s[]={&123\n&};
D．char s[4]={'1'，'2'，'3'}; 解析：字符数组中所存字符中有’\0’时，字符数组才能作为字符串使用。选项A是用字符常量对字符数组初始化，且最后一个元素的值为字符串结束标记（’\0’），所以数组s中存放的就是字符串&123&；选项D是用字符常量对部分元素初始化，根据 C语言的规定，系统为第四个元素赋初值为空值，即'\0'，所以数组s中存放的也是字符串& 123&。选项B是直接使用字符串&123&对字符数组初始化；选项C也是使用字符串初始化，但是字符串不是&123&，而是&123＼n&，数组长度为5。 答案：C 【例4.17】下列程序的功能是输入N个实数，然后依次输出前l个实数和、前2个实数和、?、前N个实数和。填写程序中缺少的语句。 #define
10 main() { float f[N],x=0.0; for(i=0;i&N;i++) scanf(&%f&,&f[i]); for(i=1;i&=N;i++) { ① ; printf(&sum of NO %2d---------%f\n&,i,x); } } 解析：分析程序可知，第一个循环实现数据的输入，第二个循环实现求和并输出，程序中缺少的是计算前i个实数和并存入变量x的语句。由于每次循环的x值都是在前一次循环的基础上作累加，即前i个实数和（x）等于前i-1个实数和（x）加上第i个实数f[i-1]，因此，①处应填写：x＝x＋f[i-1]；。 答案：x=x＋f[i－l］; 或
x＋＝f[i－l]; 【例4.18】下面程序的功能是检查一个N×N矩阵是否对称（即判断是否所有的a[i][j]等于a[j][i]）。请填空。 #define N 4 main() { int a[N][N]={1,2,3,4,2,2,5,6,3,5,3,7,4,6,7,4}; int i,j,found=0; for(j=0;j&N-1; j++) for(①i&N; i++) if(a[i][j]!=a[j][i]) {② ;
} if(found) printf(&No&); else printf(&Yes&); } 解析：设置判断标志found，初始值为0。对于主对角线以上每个元素，分别与对称元素比较，若不相等，则将found置为1并结束比较。循环结束后，根据found的值确定是否对称。 答案：① i=j+1 ② found=1 【例4.19】编写程序，从一整型数组a的第一个元素开始，每三个元素求和并将和值存入到另一数组中（最后一组可以不足3个元素），最后输出所求的所有和值且每行输出5个值。 解析：用于存储和值的数组设为b，所有元素都初始化为0。从数组a的第一个元素开始，进行累加操作b[j]+=a[i]，累加过程中，数组a的下标每自加3次，数组b的下标自加1次。重复此操作，直到数组a的所有元素累加完为止。输出时，每输出5个元素输出一次换行符&\n&。 #define N
20 #define M
N/3+1 main() { int
a[N],i,j,b[M]={0}; for(i=0;i&N;i++)
scanf(&%d&,&a[i]); for(i=0,j=0;i&N;i++) { b[j]+=a[i]; if((i+1)%3==0) j++; } if(N%3==0) j--; for(i=0;i&=j;i++) { printf(&%d &,b[i]); if((i+1)%5==0) printf(&\n&); } } 【例4.20】已知数组b中存放N个人的年龄，编写程序，统计各年龄段的人数并存入数篇二：c语言数组习题 数组练习解答 1 定义一个名为a的单精度实型一维数组，长度为4，所有元素的初值均为0的数定义语句是___________ 【分析】按照一般数据定义语句的格式，可以直接写出方法一（参看答案）；考虑到所有元素均赋初值时可以省略数组长度，可以写出方法二（参看答案）；考虑到不省略数组长度，给部分元素赋初值时，所有未赋初值的元素均有空值（对数值型数组来说，初值为0），可以写出方法三（参看答案）；考虑到选用静态型，不赋初值所有元素也自动赋予。空值（对数值型数组来说，初值为0），可以写出方法四（参看答案）。 【答案】方法一：float a[4]＝{0．0，0．0，0．0，0．0}； 方法二：float a[]＝{ 0．0，0．0，0．0，0．0}； 方法三：float a[4]= {0．0}； 方法四： static float [4]； 2 下列数组定义语句中，错误的是（） ① char x[1]＝'a'； ②auto char x[1]={0}； ③ static char x[l]；
④ char x[l]； 【分析】显然答案①中给字符型数组赋初值的格式不对（不能直接赋予字符常量，必须用花括号括住），所以备选答案①是符合题意的答案。 【答案】 ① 3 用&冒泡排序法&对n个数据排序，需要进行n一1 步。其中第k步的任务是：自下而上，相邻两数比较，小者调上；该操作反复执行n－k次。现在假设有4个数据：4、l、3、2要排序，假定4为上、2为下，则利用&冒泡排序法&执行第2步后的结果是_________________。 【分析】开始排序前的排列执行第1步后的排列执行第2步后的排列 4 11 1 42 3 24 2 33 【答案】 l、2、4、3 4 用&选择排序法&对n个数据排序，需要进行n－1步。其中第k步的任务是：在第k个数据到第n个数据中寻找最小数，和第k个数据交换。现在假设有4个数据：4、1、3、2要排序，则利用&冒泡排序法&执行第2步后的结果是______________________。 【分析】
开始排序前的排列为： 4 1 3 2 执行第1步后的排列为：1
4 3 2 执行第2步后的排列为：1
2 3 4 【答案】1、2、3、4 5 下列数组定义语句中，正确的是（） ① int a[][]={1，2，3，4，5，6}；② char a[2]「3]＝'a'，'b'； ③ int a[][3]= {1，2，3，4，5，6}； ④ static int a[][]＝{{1,2,3},{4,5,6}}； 【分析】C语言规定，二维数组定义时不允许省略第二维的长度，所以备选答案①④是错误的。C语言还规定，定义字符型数组时不允许直接使用&字符常量&的方式赋初值，所以备选答案②也是错误的。显然备选答案③符合题意。【答案】③ 6 定义一个名为&s&的字符型数组，并且赋初值为字符串&123&的错误语句是（） ①char s[]={‘1'，'2'，'3'，'\0 '}； ②char s「」={&123&}； ③char s[]={&123\n&};④ char s[4]={'1'，'2'，'3'}； 【分析】备选答案①中省略了数组长度，所以每个元素都赋了初值，共计4个元素，初值依次为'l'、'2'、'3'、'＼0'，最后一个元素的值为字符串结束标记，所以数组S中存放的是字符串&123&，该答案不符合题意（即正确的）；备选答案③中直接赋予字符串作为初值所以数组s的长度为4，其中的初值是字符串&123&，不符合题意（即正确的）；备选答案③中也是给数组s赋予字符串的初值，但是字符串不是&123&，而是&123＼n&，所以该答案符合题意（即错误的）；显然答案④也不符合题意（即正确的）。下面来分析答案④为什么是正确的，该答案给出了数组长度为4，赋初值时仅给前3个元素赋予字符'1 '、 '2'、'3'，第 4个元素没有赋初值，按照 C语言的规定，也有初值，且初值为空值， 对字符型数组来说，空值就是'＼0'，即字符率结束标记，所以数组S中存放的也是字符串& 123&。【答案】③7 设有下列数据定义语句，则数组元素x[i]的值是__________________。 int i＝ 3，x[4]={ 1，2，3}； 【分析】由于i的初值为3，所以x[i]就是x[3]。由于数组的下标是从0开始的，所以x[3］实际上是数组x的第4个元素。从定义语句中可以看出数组x的前3个元素的初值依次为1、2、3，第4个元素没有赋初值，其初值自动设为空值，对整型数组来说，空值是0，显然x[3」的值是0.【答案】0 8 设有下列数据定义语句，则 puts（＆s[0][0]）的输出结果是__________； puts（s[0]〕 输出结果是_____________。 char s[4][5]={{'l'，'＼0'}，{&23&}，&345&，&4＼0&}； 【分析】首先分析字符型数组s的初值，s的第1行中存放的字符串是&1&、第2行中存放的符串是&23&、第3行中存放的字符串是&345&、第4行中存放的字符串是&4&。puts（）函数的功能是输出从&参数&处开始存放的字符串中有效字符。按照上的分析，第1个输出的结果是从&＆S[0][0]&开始的字符串，这个地址对应的就是数s的第1行，所以输出结果为1；第2个输出的结果是从“s[]”开始的字符串，这个址对应的也是数组s的第1行，所以输出结果也为1。 【答案】
1 1 9 设有下列数据定义语句： char a[4][10]={&11&，&22&，&33&，&44&}； 则 puts（strcat（a[1]，a[3]））的输出结果是________________； putS（strcpy（a[0]，a[2]））的输出结果是＿_______________。 【分析】字符数组a共有4行，每行存放一个字符串。这4行的首地址依次为：a[0]、a[1]、a[2]、a[3]，从这4个地址开始存放的字符串依次为：&11&、&22&、&33&、&44&。strcat（a[1]，a[3]）函数调用的功能是将s[3]处的字符串连接到a[l]的字符串后面，所以执行该函数调用后的「al」处的字符串为&2244&，而该函数的返回值就是a[1]的首地址，puts（）函数的功能就是输出这个地址存放的字符串，由此，第1个输出的结果就是：2244。同样理由可以分析strcpy（a[0]，a[2]）的功能是将a[2]处的字符串（&33&）复制到a[0]处，返回a[0]的地址，puts()输出的就是a[0]处的字符串，结果为：33。 【答案】2244
33 10 设有下列数据定义语句： char str[2][10]={&abc&，&ABC&}； 则printf(&％d&，strcmp（str[1]，str[0］））的输出结果是__________； printf（&％d&，strcmp(strlwr(str[1],str[0]）），str[0]））的输出结果是_______。 【分析】字符型数组str中，从str[0]开始存放的字符串是&abc&、从str[l]开始存放的字符串是&ABC&。strcmp(str[l]，str[0]）是比较str[l]和str【0」处的两个字符串的大小，由于&ABC&是小于&abc&的，按照srrcmp函数的功能可知，返回值是一个小于0的整数，这是第1个空的答案。再来分析第2个空的答案，strlwr（str[l]）函数的功能是将str[l]处的字符串中大写字母改为小写字母，其返回值是修改后字符串的地址。strcmp（stlwr（sir[1]），str[0]））函数的功能是比较str[l]和str[0]处的字符串，由于str[l]处的字符串已经改为小写字母了，所以和 str[0]处的字符串完全相同，返回值是0，这就是第2个空的答案。 [答案]某个小于0的任意整数0 11 下列程序的功能是读取10个实数，然后依次输出前l个实数和、前2个实数和、?、前9个实数和、前10个实数和。请填写程序中缺少的语句。 main（） {float f[10]，X＝0．0； int i； for（i=0；i＜10；i++） scanf（& ％ f&， ＆f[i]）； for（i=1;i＜=10；i++） {_______________________ printf（&sum of NO ％2d－－－－％f＼n&，i，x）； } } 【分析】浏览程序清单后，可以发现前一个次数型循环是输入 10个实数存入数组 f中。后一个次数型循环是计算前i个实数和并存入变量X中，然后再输出这个x的值。程序中所缺少的语句就是实现&计算前i个实数和并存入变量X中&的。当i等于1时，x要等于f[0］的值，即f[i－l］的值；当i等于2时，x要等于f[0] ＋f[l]的值，即f[0]＋f[i－1」的值，此时f[0]的值已经计算并存入变量x中；当i等于3时，x要等于f[0]＋f[1]＋f[2]的值，即f[0］＋f[1]＋f[i－l］的值，此时f[0]＋f[1]的值已经计算并存入变量x中；由此可以推出：前i个值的计算公式为：x＝x＋f[i－1]，将这个表达式组成语句就是需要填写的内容。 【答案】 x=x＋f[i－l］； 或
x＋＝f[i－l]； 12 运行下列程序的输出结果是（） ① 111ll
②llll③lll
④ 222 main（） {int a[]={1，2，3，4， 5 }，i; for（ i=1;i＜ 5； i＋＋） printf（&％ 1d&， a[i]－ a[i一1]）； } 【分析】首先分析数组a各元素的值，由于是赋初值，很容易看出：a[0]＝ 1、a[1]＝2?、a[4]＝5。再分析次数型循环共计执行4次（i＝1、i＝2、i＝3、i＝4），每次输出1位整数；[i]－a[i－1］，当i＝1时，输出的是2－1＝1；当i＝2时，输出的是3－2＝l；当i=3时，输出的是4－3＝l；当i＝4时，输出的是5－4＝1。整个程序的输出结果是1111。 【答案】② 13 下列程序的功能是输入一个5行5列的实数矩阵，然后求出其中的最大数和最小数，并且对调这两个数后，再输出，请填写程序中缺少的语句。 main（） { float f[ 5][5]，max， x； int i，j，max_l，max_J，min_i，min_J； for（i＝0；i＜5；i＋＋） for（j＝0；j＜5；j＋＋） {scanf（&％f&，＆x）； f[i][j]＝x； } max＝min＝f[0][0]； max_i＝max_i＝min_i＝min_j＝ 0; for（i= 0；i＜5；i＋＋） for（j＝0；j＜5；j＋＋） {if（max＜f[i][j]） max＝f[i][j]，max_i＝i，max_j＝j； if（min＞f[i][j]） ___________________ } f[max_i][max_j]＝ f[min_i］[min_j］＝max； for(i＝0；i＜5；i＋＋） {printf(&＼n&）； for（j＝0；j＜5；j＋＋） printf（&％8．2f&，f[i][j]）； } } 【分析】首先宏观上阅读程序，可以看出程序的基本结构是：用双重次数型循环读取5行5列矩阵的元素值存入二维数组f中；寻找矩阵中的最大数和最小数；交换最大数和最小数；输出交换后的矩阵元素值。需要填写的语句属于第2个部分。现在来仔细分析这个部分的程序。通常寻找最大数（或最小数）的算法是首先假定最前面的数是最大数（或最小数），并记录该数及其在数组中的下标，然后依次处理所有元素，若当前处理的元素大于（小于）最大数（最小数），则重新记录新的最大数（最小数）及其下标。从本程序清单来看，的确是采用了这个算法，由于是同时求最大数和最小数，所以用max、max_i、max_j分别记录当前的最大数及其行列下标，用min、min_i、min_j分别记录当前的最小数及其行列下标。在二重循环的循环体中有两条单分支语句，前一个单分支语句的功能很清楚，判断当前的数组元素是否大于最大数，是则重新记录最大数及其行列下标（注意，这里是用一个逗号表达式完成三项赋值工作的）。循环体中的第2条单分支语句当然是求当前最小数的，由此分析，当条件成立（当前数组元素小于当前最小数）时，需要重新记录当前的最小数及其行列下标，所缺少的语句正是完成这项工作的，由于只能用一条语句完成三项赋值工作，所以必须使用远号表达式。对照该循环体的前一个单分支语句，很容易写出所缺少的语句。接下来阅读以后的程序，来验证所填写的语句。接下来的两条赋值语句正好完成了最大数和最小数的交换工作。前一个语句“f[max_i][max_j]＝ min；”是将找到的最小数存入对应最大数的位置（max＿i是最大数的行下标，max_i是最大数的列下标，f[max_i][max＿j］就是最大数），类似的，后一个语句“f[min＿i][min_j〕＝max ；”是将找到的最大数存入对应最小数的位置。 【答案】min＝f[i][j]，min＿i＝i，min＿j=j； 14 阅读下列 程序，写出程序运行后的输出结果。 main（） ｛int al[]={1，3，6，7，100}，a2[]={2，4，5，8，100}，a[10]，i，j，k； i＝j＝0； for（k＝0；k＜8；k＋＋） if（a1[i]&a2[j]） a[k]＝a1[i＋＋］； else a[k］＝a2[j＋＋]； for （k＝ 0； k＜ 8； k＋＋ ） printf（&％1d&，a[k]）； } 【分析】程序开始用赋初值方式给数组al和a2的所有元素赋值。接下来是给变量 i、j清0，从后面的for循环中可以看出，变量i、j是作为一维数组的下标的，所以它们的初值是从0下标开始的。重点分析其后的次数型循环，共计循环8次，控制变量k的值依次为0、l、?、7，这个控制循环的变量k也是作为下标使用的。再分析循环体，这是一条双分支语句，控制条件是“a1[i]＜a[j]”，即a1数组的第叶元素值小于a2数组的第j个元素值。这个条件成立时，执行的操作包括： al数组的第i个元素存入 a数组的第 k个元素中、同时 i加1，使得 a1[i]成为其后的元素；如果这个条件不成立（即a2数组的第 j个元素值小于或等于 al数组的第 i个元素值），执行的操作包括： a2数组的第j个元素在入a数组的第k个地素中、同时j加1，使得a2[j]成为其后的元素。综合上述的分析，可以看出，循环体的工作是将数组al和a2的当前元素中值小的元素复制到数组 a中，如果数组 al的元素被复制，则其下标后移一个位置，指向 al的新元素；如果数组a2的元素被复制，则其下标后移一个位置，指向a2的新元素。该循环执行8次，恰好把数组a1和数组a2中的各4个元素按照从小到大的顺序复制到数组a中。最后看看输出，是一个次数型循环语句，输出的结果是数组a中的8个元素值，而且输出格式为一位整数，结果当然是： 。 请读者注意，由于原来的两个数组al和a2中的元素是从小到大的顺序排列的，所以合并后的数组a的元素也必然是从小到大的。这是一种排序的算法，称为&两路归并排序法&。但是，真正的两路归并排序法要考虑到某个数组的元素全部复制后，另一个数组中的剩余元素要全部复制。本程序中没有考虑这个&临界问题&，而是采用了在两个数组的有效数据之后，放一个最大数的方法，并且知道归并后的数据总个数。【答案】
15 阅读下列程序，写出程序运行后的输出结果。 ＃include &string.h& main（） {char s[3][20]={&2345&，&123456&，&2347&}； int i， k； for（ k＝ 0， i＝1； i＜ 3； i＋＋） if（（strcmp（s[k]，s[i]））＜0） k＝ i： puts（s「k」）; }【分析】该程序很简单，开始给二维字符型数组赋初值为3个字符串，通过一个次数型循环求得变量k的值，然后输出s[k]对应的字符串。从上面的分析可知，关键是循环语句执行后变量k的值等于多少？我们呵以用记录的方法来记录在循环中变量k的值。 执行循环语句，记录如下： k＝0，i＝1，控制循环的条件&i＜ 3'成立，执行循环体的单分支语句，条件&（strcmp （s[k]，s[i]））＜0&相当于&（strcmp（&2345&，&123456&））＜0&，条件不成立，变量k值不变，i加1后继续循环； k＝0，i＝ 2，控制循环的条件&i＜ 3&成立，执行循环体的单分支语句，条件&（strcmp （s[k]，s[i]））＜0&相当于&（strcmp（&2345&，&2345&））＜0&，条件成立，执行k＝i，k值为2，i加1后继续循环； k＝2，i=3，控制循环的条件&i＜3&不成立，退出循环。 此时变量k值为2. 执行&puts（s[k]）；&语句，输出的是s[2]处存放的 字符串：2347 显然该程序的主要功能是在3个字符串中。寻找最大字符串的 【答案】 2347 16 阅读下列程序，写出程序的主要功能。 main（） { int i， a[10]， x， flag＝ 0； for（i=0; i&10；i十十） scanf（&％d&，＆ a 【i】）； scanf（&％d&，＆ X）； for（i=0;i＜10;i十十） if（ x＝＝ a[i]） { flag＝ i十1; break； } if(flag== 0 ） printf（&no found!＼n&）； else printf（&％d＼n&，flag）； } 【分析】该程序属于比较简单的，开始定义整型数组a以及整型变量x、flag和i。下面的次数型循环是输入10个整数到数组a中，此时可以看出变量i是作为循环的控制变量使用的。接着输入一个整数到变量x中。接下来的次数型循环执行10次，这是标准的用单重次数型循环来依次处理一维数组元素的程序段，处理的内容是循环体中的单分支语句，即判断当前的数组元素是否等于变量x，是，则在变量师中记录 i＋1后退出循环；否，则继续循环。由此可以分析出，这个流环足在数组a中寻找x的，找不到，则变社flag的值不会改变（注意动值为0）；如果找到，则lleq变量的值将等于i＋l，其中的i是循环控制变量，也就是找到的数组元素的下标，将其加 1后存入变量flag，所以此时的flag是对应数组元素的下标加 1的。我们再仔细分析一下，当i＝0时，找到的是数组元素a[0]，此时flag为1，表示是数组的第1个元素，即在10个待查整数中的序号为 1；当 i＝ l时，找到的是数组元素 a[1]，此时 flag为2，表示是数组的第 2个元素，即在 10个待查整数中的序号为 2. 当 i＝9时，找到的是数组元素a[9]，此时 flag为10，表示是数组的第1O个元素，即在10个待查整数中的序号为10.所以，找到则flag的值为1、2、?、10；找不到则为0。循环后面的输出恰好是按照flag的值分别处理找到和找不到的两种情况。综上所述，可以出本程序的主要功能。 【答案】输入10个整数存入数组a，再输入一个整数x，在数组a中查找x。找到输出x在10个整数中的序号（从1开始），找不到则输出&no found！&。 17 阅读下列程序，写出程序的主要功能。 main（） { int i，sum＝ 0，a[ 10]; for（i＝0；i＜10；i＋＋） scanf（&％ d&，＆a[i]）；篇三：C语言程序设计 练习题参考答案 第四章 一维数组 C语言程序设计 练习题参考答案 第四章(1) 一维数组 /*
4.11 fibonacci数列，前15项1，1，2，3，5，。。。。。*/ #include &stdio.h& void main() { int f[15]={1,1}, for(i=2;i&=14;i++) /* 计算 */ f[i]=f[i-2]+f[i-1]; printf(&fibonacci数列，前15项\n&); /* 输出 */ for(i=0;i&=14;i++) { printf(&%5d&,f[i]); if((i+1)%5==0) printf(&\n&); } } /*
4.12 数组元素前移动一个位置 */ #include &stdio.h& void main() { int a[10]={0,1,2,3,4,5,6,7,8,9}; int i,t; printf(&\n移动之前:\n&); for(i=0;i&=9;i++) printf(&%3d&,a[i]); /* 移动 */ t=a[0]; for(i=0;i&=9;i++) a[i]=a[i+1]; a[9]=t; printf(&\n移动之后:\n&); for(i=0;i&=9;i++) printf(&%3d&,a[i]); } /*
4.13 有序数列中插入若干个数，仍然保持有序 */ #include &stdio.h& void main() { int a[100]={1,4,8,10}; int i,k,x,count=4;/* i,k 循环变量， x 输入整数，count 有多少整数*/printf(&\n请输入要插入的整数,输入之后按回车键,如要结束请输入-1\n&);scanf(&%d&,&x); while(x!=-1) {/* 寻找插入位置 */ for(i=0;i&i++) { /* 找到插入位置 */ if(a[i]&=x) { /* 移动 */ for(k=k&i;k--) a[k]=a[k-1]; /* 插入 */ a[i]=x;
} } if(i&=count) a[i]=x; count=count+1; printf(&\n插入之后的数组为：\n&); for(i=0;i&i++) printf(&%4d&,a[i]); printf(&\n请输入要插入的整数,输入之后按回车键,如要结束请输入-1\n&);scanf(&%d&,&x); } } /*
4.15 将十进制数转换成二进制数，并按位存放到数组中。（限正整数） */
#include &stdio.h& #include &conio.h& void main() { int
decimal, binary[32], i=0, printf(&请输入一个十进制数\n&); scanf(&%d&,&decimal); /* 计算 */ quotient=decimal/2; binary[i]=decimal%2; decimal= while(quotient!=0) { i++; quotient= decimal/2; binary[i]=decimal%2; decimal= } /* 输出 */while(i&=0) { printf(&%d&,binary[i]);i--; } getch(); }
友情链接：