C语言之：数组的定义和初始化必备练习题

作业标题(688)

关于一维数组初始化，下面哪个定义是错误的？（）

作业内容

A.int arr[10] = {1,2,3,4,5,6};

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

C.int arr[] = (1,2,3,4,5,6);

D.int arr[10] = {0};

答案解析(提交后可在已完成作业列表查看答案)

答案解析：

A：正确，10个int的一段连续空间，前6个位置被初始化为1,2,3，4,5,6，其他位置为0

B：正确，数组中有6个空间，并被初始化为1,2,3,4,5,6

C：错误，数组的初始化不能使用()，只能使用{}

D：正确，10个int类型的一段连续空间，每个位置都被初始化为0

因此，选择C

作业标题(690)

定义了一维 int 型数组 a[10] 后，下面错误的引用是：（）

作业内容

A.a[0] = 1;

B.a[0] = 5*2;

C.a[10] = 2;

D.a[1] = a[2] * a[0];

答案解析(提交后可在已完成作业列表查看答案)

答案解析：

数组是相同类型的一段连续的空间，下标是从0开始的，比如：int array[N]

下标的范围为[0,N),其中N位置不能存储有效元素

A：正确，将0号位置设置为1

B：正确，将0号位置设置为10

C：错误，越界

D：正确，1号位置初始化为a[2]*a[0]之后的结果

因此，选择C

作业标题(691)

若定义int a[2][3]={1,2,3,4,5,6};则值为4的数组元素是( )

作业内容

A.a[0][0]

B.a[1][0]

C.a[1][1]

D.a[2][1]

答案解析(提交后可在已完成作业列表查看答案)

答案解析：

int a[2][3]表示2行3类的二维数组，根据其初始化知：

第0行即a[0]存储3个元素： 1,2,3

第1行即a[1]存储3个元素： 4,5,6

因此值为4的元素在第1行第0列

因此，选择B

作业标题(692)

下面代码的结果是：( )

#include <stdio.h>
int main()
{int arr[] = {1,2,(3,4),5};printf("%d\n", sizeof(arr));return 0;
}

作业内容

A.4

B.16

C.20

D.5

答案解析(提交后可在已完成作业列表查看答案)

答案解析：

对于int arr[] = {1,2,(3,4),5}数组，里面总共有4个元素，(3,4)为逗号表达式，取后者，因此数组中元素分别为：1,2,4,5

而sizeof(arr)求的是整个数组所占空间的大小，即：4*sizeof(int)=4*4=16

因此，选择B

作业标题(693)

下面代码的结果是：( )

#include <stdio.h>
int main()
{char str[] = "hello bit";printf("%d %d\n", sizeof(str), strlen(str));return 0;
}

作业内容

A.10 9

B.9 9

C.10 10

D.9 10

答案解析(提交后可在已完成作业列表查看答案)

答案解析：

str字符数组使用"hello bit"初始化，最终也会将'\0'放置到数组中，因此数组中总共有10个元素

sizeof(str)：获取数组的总大小，10个元素，每个元素占1个字节，因此总共是10个字节

strlen(str): 获取字符串中有效字符的个数，不算'\0'，因此总共9个有效字符

故上述printf会分别打印：10 9

因此，选择A

作业标题(694)

给出以下定义：

char acX[] = “abcdefg”;
char acY[] = {‘a’,’b’,’c’,’d’,’e’,’f’,’g’};

以下说法正确的是( )

作业内容

A.数组acX和数组acY等价

B.数组acX和数组acY的长度相同

C.sizeof(acX)>sizeof (acY)

D.strlen (acX)>strlen (acY)

答案解析(提交后可在已完成作业列表查看答案)

答案解析：

acX和acY都是字符数组，但是初始化表达式不同，acX和acY的区别如下：

acX：数组中总共有8个元素，分别是：'a','b','c','d','e','f','g','\0'

acY：数组中总共有7个元素，分别是：'a','b','c','d','e','f','g'

sizeof求的是有效元素个数

strlen求的是字符串长度，从首元素开始计算，遇见‘\0’停止，由于acY数组没有'\0‘，所以strlen(acY)的结果是个随机值

因此，选择C

作业标题(695)

关于一维数组描述不正确的是：( )

作业内容

A.数组的下标是从0开始的

B.数组在内存中是连续存放的

C.数组名表示首元素的地址

D.随着数组下标的由小到大，地址由高到低

答案解析(提交后可在已完成作业列表查看答案)

答案解析：

A：正确，C语言规定，数组的下标是从0开始的

B：正确，数组的空间是一段连续的内存空间

C：正确，数组名既可以表示数组的地址，也可以表示数组首元素的地址，两个在数值上是一样的，但是含义不一样。

注意：数组名只有在sizeof和&后才代表整个数组，其它都表示首元素的地址

D：错误，这个要是系统而定，一般都是下标由小到大，地址由低到高

因此，选择D

8‘

作业标题(689)

以下能对二维数组a进行正确初始化的语句是：（）

作业内容

A.int a[2][]={{0,1,2},{3,4,5}};

B.int a[][3]={{0,1,2},{3,4,5}};

C.int a[2][4]={{0,1,2},{3,4},{5}};

D.int a[][3]={{0,,2},{},{3,4,5}};

答案解析(提交后可在已完成作业列表查看答案)

答案解析：

对于二维数组int array[M][N], 说明如下：

1. M和N都必须为常数，

2. M代表数组有M行，N代表每行中有N个元素

3. 其中M可以省略，省略后必须给出初始化表达式，编译器从初始化结果中推断数组有多少行

4. N一定不能省略，因为N省略了就不能确定一行有多少个元素，也不能确定数组有多少行

A：错误，参数上述说明

B：正确，参考上述说明

C：错误，数组有两行，但是初始化给了三行

D：错误，初始化不允许{0,,2}该种情况存在

因此，选择B

作业标题(696)

交换数组

作业内容

将数组A中的内容和数组B中的内容进行交换。（数组一样大）

参考代码为：

将数组A中的内容和数组B中的内容进行交换。（数组一样大）
#include <stdio.h>int main()
{int arr1[4] = { 1,2,3,4 };int arr2[4] = { 5,6,7,8 };int i = 0;int swap[10] = { 0 };for (i = 0; i < 4; i++){swap[i] = arr1[i];arr1[i] = arr2[i];arr2[i] = swap[i];}for (i = 0; i < 4; i++){printf("arr1[%d]=%d ",i, arr1[i]);}printf("\n");for (i = 0; i < 4; i++){printf("arr2[%d]=%d ",i, arr2[i]);}return 0;
}

代码的运行结果为：

10.

作业标题(697)

数组操作

作业内容

创建一个整形数组，完成对数组的操作

实现函数init() 初始化数组为全0
实现print() 打印数组的每个元素
实现reverse() 函数完成数组元素的逆置。

要求：自己设计以上函数的参数，返回值。

参考代码为：

#include <stdio.h>//初始化函数
void init(int a[], int sz) {int i;for (i = 0; i < sz; i++) {a[i] = 0;}
}//打印函数
void print(int arr[], int sz)
{int i = 0;for (i = 0; i < sz; i++){printf("%d ", arr[i]);}printf("\n");
}//逆序函数
void reverse(int a[], int sz){int t;int left = 0;int right = sz - 1;while (left < right) {t = a[left];a[left] = a[right];a[right] = t;left++;right--;}
}
int main() {int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };int sz = sizeof(arr) / sizeof(arr[0]);//init(arr, sz);print(arr, sz);reverse(arr, sz);print(arr, sz);return 0;
}

代码的运行结果为：

11.

作业标题(698)

冒泡排序

作业内容

实现一个对整形数组的冒泡排序

参考代码为：

//实现一个对整形数组的冒泡排序
//由大到小排序
#include <stdio.h>
void maopao(int arr[], int sz)
{int i = 0;int j = 0;///确定冒泡排序趟数for(i=0;i<=sz-1;i++){     /*每一趟的冒泡排序进行几次（总趟数（次数）去掉沉底的）*///int j = 0;for (j = 0; j < sz - 1 - i; j++){if (arr[j] < arr[j + 1]){int tmp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = tmp;}}}
}
int main()
{int i = 0;int arr[10] = { 1,5,6,4,8,2,10,9,3,7 };int sz = 0;sz=sizeof(arr) / sizeof(arr[0]);//printf("sz=%d\n", sz);     //计算得出sz=10for (i = 0; i < 10; i++){printf(" % d ", arr[i]);}printf("\n");maopao(arr, sz);for (i = 0; i < 10; i++){printf(" %d  ", arr[i]);}
}

代码的运行结果为：

或者：专家解析

/*
思路：
遍历数组，对数组中相邻的两个元素进行比较，如果需要升序，前一个数据大于后一个数据时，交换两个位置上的数据，直到所有的数据比较完，此时，最大的数据已经放在数组的末尾。
除最大数据已经排好序外，其余数据还是无需，对剩余数据采用与上述类似的方式进行处理即可
*/void BubbleSort(int array[], int size)
{// 外层循环控制冒泡排序的趟数// size-1表示：最后一趟区间中只剩余1个元素，该趟冒泡可以省略for(int i = 0; i < size-1; ++i){// 具体冒泡的方式：用相邻的两个元素进行比较，前一个大于后一个元素时，交换着两个数据，依次直到数组的末尾for(int j = 1; j < size-i; ++j){if(array[j-1] > array[j]){int temp = array[j-1];array[j-1] = array[j];array[j] = temp;}}}
}/*
优化：如果某次冒泡结束后，序列已经有序了，后面剩余元素的冒泡可以省略
*/void BubbleSort(int array[], int size)
{// 外层循环控制冒泡排序的趟数// size-1表示：最后一趟区间中只剩余1个元素，该趟冒泡可以省略for(int i = 0; i < size-1; ++i){int isChange = 0; // 具体冒泡的方式：用相邻的两个元素进行比较，前一个大于后一个元素时，交换着两个数据，依次直到数组的末尾for(int j = 1; j < size-i; ++j){if(array[j-1] > array[j]){int temp = array[j-1];array[j-1] = array[j];array[j] = temp;isChange = 1;   // 如果本次冒泡进行数据交换了，说明本次还是无序的，就将isChange设置为1}}// 如果本次冒泡中，元素没有交换，则本次开始冒泡时，数据已经有序了，后面的冒泡可以不用进行了if(!isChange)return;}
}

12. 矩阵计算：参考链接为：矩阵计算_牛客题霸_牛客网 (nowcoder.com)

描述

输入NxM矩阵，矩阵元素均为整数，计算其中大于零的元素之和。

输入描述：

第一行为N M(N: 矩阵行数；M: 矩阵列数,且M,N<=10)，接下来的N行为矩阵各行。

输出描述：

一行，其中大于零的元素之和。

示例1

输入：

输出：

参考代码为：

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

13. 矩阵转置：参考链接为：矩阵转置_牛客题霸_牛客网 (nowcoder.com)

描述

KiKi有一个矩阵，他想知道转置后的矩阵（将矩阵的行列互换得到的新矩阵称为转置矩阵），请编程帮他解答。

输入描述：

第一行包含两个整数n和m，表示一个矩阵包含n行m列，用空格分隔。 (1≤n≤10,1≤m≤10)

从2到n+1行，每行输入m个整数（范围-231~231-1），用空格分隔，共输入n*m个数，表示第一个矩阵中的元素。

输出描述：

输出m行n列，为矩阵转置后的结果。每个数后面有一个空格。

示例1

输入：

2 3
1 2 3
4 5 6

输出：

1 4
2 5
3 6

参考代码为：

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