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

    1.

     

    作业标题(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

    2.

    作业标题(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

    3.

    作业标题(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

    4.

    作业标题(692)

    下面代码的结果是：( )

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

    作业内容

    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

    5.

    作业标题(693)

    下面代码的结果是：( )

    1. #include 
    2. int main()
    3. {
    4.     char str[] = "hello bit";
    5.     printf("%d %d\n", sizeof(str), strlen(str));
    6. 	return 0;
    7. }

    作业内容

    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

    6.

    作业标题(694)

    给出以下定义：

    1. char acX[] = “abcdefg”;
    2. 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

    7.

    作业标题(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

    9.

    作业标题(696)

    交换数组

    作业内容

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

    参考代码为：

    1. 将数组A中的内容和数组B中的内容进行交换。（数组一样大）
    2. #include <stdio.h>
    3.  
    4. int main()
    5. {
    6. 	int arr1[4] = { 1,2,3,4 };
    7. 	int arr2[4] = { 5,6,7,8 };
    8. 	int i = 0;
    9. 	int swap[10] = { 0 };
    10. 	for (i = 0; i < 4; i++)
    11. 	{
    12. 		swap[i] = arr1[i];
    13. 		arr1[i] = arr2[i];
    14. 		arr2[i] = swap[i];
    15. 	}
    16. 	for (i = 0; i < 4; i++)
    17. 	{
    18. 		printf("arr1[%d]=%d ",i, arr1[i]);
    19. 	
    20. 	}
    21. 	printf("\n");
    22. 	for (i = 0; i < 4; i++)
    23. 	{
    24. 		printf("arr2[%d]=%d ",i, arr2[i]);
    25. 		
    26. 	}
    27. 	return 0;
    28. }

     代码的运行结果为：

     10.

    作业标题(697)

    数组操作

    作业内容

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

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

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

    参考代码为：

    1. #include <stdio.h>
    2.  
    3. //初始化函数
    4. void init(int a[], int sz) {
    5. 	int i;
    6. 	for (i = 0; i < sz; i++) {
    7. 		a[i] = 0;
    8. 	}
    9. }
    10.  
    11. //打印函数
    12. void print(int arr[], int sz)
    13. {
    14. 	int i = 0;
    15. 	for (i = 0; i < sz; i++)
    16. 	{
    17. 		printf("%d ", arr[i]);
    18. 	}
    19. 	printf("\n");
    20. }
    21.  
    22. //逆序函数
    23. void reverse(int a[], int sz)
    24.   {
    25. 	int t;
    26. 	int left = 0;
    27. 	int right = sz - 1;
    28. 	while (left < right) 
    29.  {
    30. 		t = a[left];
    31. 		a[left] = a[right];
    32. 		a[right] = t;
    33. 		left++;
    34. 		right--;
    35. 	}
    36. }
    37. int main() {
    38. 	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    39. 	int sz = sizeof(arr) / sizeof(arr[0]);
    40. 	//init(arr, sz);
    41. 	print(arr, sz);
    42. 	reverse(arr, sz);
    43. 	print(arr, sz);
    44. 	return 0;
    45. }

    代码的运行结果为：

     11.

    作业标题(698)

    冒泡排序

    作业内容

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

    参考代码为：

    1. //实现一个对整形数组的冒泡排序
    2. //由大到小排序
    3. #include <stdio.h>
    4. void maopao(int arr[], int sz)
    5. {
    6. 	int i = 0;
    7. 	int j = 0;
    8. 	
    9. 	///确定冒泡排序趟数
    10. 	for(i=0;i<=sz-1;i++)
    11. 	{     /*每一趟的冒泡排序进行几次（总趟数（次数）去掉沉底的）*/
    12. 		//int j = 0;
    13. 		for (j = 0; j < sz - 1 - i; j++)
    14. 		{
    15. 			if (arr[j] < arr[j + 1])
    16. 			{
    17. 				int tmp = arr[j];
    18. 				arr[j] = arr[j + 1];
    19. 				arr[j + 1] = tmp;
    20. 			}
    21. 			
    22. 		}
    23.  
    24. 	}
    25. }
    26. int main()
    27. {
    28. 	int i = 0;
    29. 	int arr[10] = { 1,5,6,4,8,2,10,9,3,7 };
    30. 	int sz = 0;
    31. 	sz=sizeof(arr) / sizeof(arr[0]);
    32. 	//printf("sz=%d\n", sz);     //计算得出sz=10
    33. 	for (i = 0; i < 10; i++)
    34. 	{
    35. 		printf(" % d ", arr[i]);
    36. 	}
    37. 	printf("\n");
    38. 	maopao(arr, sz);
    39. 	
    40. 	for (i = 0; i < 10; i++)
    41. 	{
    42. 		printf(" %d  ", arr[i]);
    43. 	}
    44. }

    代码的运行结果为：

     或者：专家解析

    1. /*
    2. 思路：
    3. 遍历数组，对数组中相邻的两个元素进行比较，如果需要升序，前一个数据大于后一个数据时，交换两个位置上的数据，直到所有的数据比较完，此时，最大的数据已经放在数组的末尾。
    4. 除最大数据已经排好序外，其余数据还是无需，对剩余数据采用与上述类似的方式进行处理即可
    5. */
    6.  
    7.  
    8. void BubbleSort(int array[], int size)
    9. {
    10.     // 外层循环控制冒泡排序的趟数
    11.     // size-1表示：最后一趟区间中只剩余1个元素，该趟冒泡可以省略
    12.     for(int i = 0; i < size-1; ++i)
    13.     {
    14.         // 具体冒泡的方式：用相邻的两个元素进行比较，前一个大于后一个元素时，交换着两个数据，依次直到数组的末尾
    15.         for(int j = 1; j < size-i; ++j)
    16.         {
    17.             if(array[j-1] > array[j])
    18.             {
    19.                 int temp = array[j-1];
    20.                 array[j-1] = array[j];
    21.                 array[j] = temp;
    22.             }
    23.         }
    24.     }
    25. }
    26.  
    27.  
    28.  
    29.  
    30. /*
    31. 优化：如果某次冒泡结束后，序列已经有序了，后面剩余元素的冒泡可以省略
    32. */
    33.  
    34.  
    35. void BubbleSort(int array[], int size)
    36. {
    37.     // 外层循环控制冒泡排序的趟数
    38.     // size-1表示：最后一趟区间中只剩余1个元素，该趟冒泡可以省略
    39.     for(int i = 0; i < size-1; ++i)
    40.     {
    41.         int isChange = 0; 
    42.         // 具体冒泡的方式：用相邻的两个元素进行比较，前一个大于后一个元素时，交换着两个数据，依次直到数组的末尾
    43.         for(int j = 1; j < size-i; ++j)
    44.         {
    45.             if(array[j-1] > array[j])
    46.             {
    47.                 int temp = array[j-1];
    48.                 array[j-1] = array[j];
    49.                 array[j] = temp;
    50.                 
    51.                 isChange = 1;   // 如果本次冒泡进行数据交换了，说明本次还是无序的，就将isChange设置为1
    52.             }
    53.         }
    54.         
    55.         // 如果本次冒泡中，元素没有交换，则本次开始冒泡时，数据已经有序了，后面的冒泡可以不用进行了
    56.         if(!isChange)
    57.             return;
    58.     }
    59. }

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

     

    描述

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

    输入描述：

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

    输出描述：

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

    示例1

    输入：

    3 3
2 3 4
-5 -9 -7
0 8 -4

    输出：

    17

     参考代码为：

    1. #include <stdio.h>
    2. int main ()
    3. {
    4.     int n=0;
    5.     int m=0;
    6.     scanf("%d %d",&n,&m);
    7.     int arr[10][10]={0};
    8.     int i=0;
    9.     int j=0;
    10.     int sum=0;
    11.     for(i=0;i<n;i++)
    12.     {
    13.         for(j=0;j<m;j++)
    14.         {
    15.             scanf("%d",&arr[i][j]);
    16.         }
    17.     }
    18.     for(i=0;i<n;i++)
    19.     {
    20.         for(j=0;j<m;j++)
    21.         {
    22.             if(arr[i][j]<=0)
    23.             {
    24.                 arr[i][j]=0;
    25.             }
    26.         }
    27.     }
    28.     for(i=0;i<n;i++)
    29.     {
    30.         for(j=0;j<m;j++)
    31.         {
    32.             sum=sum+arr[i][j];
    33.         }
    34.     }
    35.     printf("%d\n",sum);
    36.     return 0;
    37. }

     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

     参考代码为：

    1. #include <stdio.h>
    2. int main ()
    3. {
    4.     int n=0;
    5.     int m=0;
    6.     scanf("%d %d",&n,&m);
    7.     int arr[10][10]={0};
    8.     int i=0;
    9.     int j=0;
    10.     for(i=0;i<n;i++)
    11.     {
    12.         for(j=0;j<m;j++)
    13.         {
    14.             scanf("%d",&arr[i][j]);
    15.         }
    16.     }
    17.     for(i=0;i<m;i++)
    18.     {
    19.         for(j=0;j<n;j++)
    20.         {
    21.             printf("%d ",arr[j][i]);
    22.         }
    23.         printf("\n");
    24.     }
    25.     return 0;
    26. }

     

  • 相关阅读:
    BES2300x笔记（8） -- 如何实现BLE数据收发
    什么是指标体系，怎么搭建一套完整的指标体系？（附PDF素材）
    Import Local Swift Package No such module TestPackage
    接口（interface）
    『Java』初试JavaAgent实现修改字节码和插桩
    jQuery实现简易购物车
    jdk8 map方法list＜Object1＞ 处理一下转成另一个List＜Obj＞
    【计算理论】复杂性类coNP
    TiDB Data Migration 快速上手指南
    质量是企业的生命，如何破解质量管控难题？质量管理系统推荐
  • 原文地址：https://blog.csdn.net/weixin_64308540/article/details/126859648