C语言初阶作业题-数组

C语言初阶作业题-数组

一、选择题

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

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.定义了一维 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.若定义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.下面代码的结果是：( )

#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)求的是整个数组所占空间的大小，即：4sizeof(int)=44=16
因此，选择B

5.下面代码的结果是：( )

#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

6.给出以下定义：

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

以下说法正确的是( )

A.数组acX和数组acY等价
B.数组acX和数组acY的长度相同
C.数组acX的长度大于数组acY的长度
D.数组acX的长度小于数组acY的长度

答案解析：
acX和acY都是字符数组，但是初始化表达式不同，acX和acY的区别如下：
acX：数组中总共有8个元素，分别是：‘a’,‘b’,‘c’,‘d’,‘e’,‘f’,‘g’,’\0’
acY：数组中总共有7个元素，分别是：‘a’,‘b’,‘c’,‘d’,‘e’,‘f’,‘g’
因此，选择C

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

A.数组的下标是从0开始的
B.数组在内存中是连续存放的
C.数组名表示首元素的地址
D.随着数组下标的由小到大，地址由高到低

答案解析：
A：正确，C语言规定，数组的下标是从0开始的
B：正确，数组的空间是一段连续的内存空间
C：正确，数组名既可以表示数组的地址，也可以表示数组首元素的地址，两个在数值上是一样的，但是含义不一样。
注意：数组名只有在sizeof和&后才代表整个数组，其它都表示首元素的地址
D：错误，这个要是系统而定，一般都是下标由小到大，地址由低到高
因此，选择D

8.以下能对二维数组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

二、编程题

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

/*
思路：
遍历数组，对数组中相邻的两个元素进行比较，如果需要升序，前一个数据大于后一个数据时，交换两个位置上的数据，直到所有的数据比较完，此时，最大的数据已经放在数组的末尾。
除最大数据已经排好序外，其余数据还是无需，对剩余数据采用与上述类似的方式进行处理即可
*/
 
 
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;
    }
}

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

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

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

/*
思路：函数比较简单，请参考实现
*/
 
 
void Init(int arr[], int sz, int set)
{
	int i = 0;
	for(i=0; i<sz; i++)
	{
		arr[i] = set;
	}
}
 
 
void Print(int arr[], int sz)
{
	int i = 0;
	for(i=0; i<sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
 
 
void Reverse(int arr[], int sz)
{
	int left = 0;
	int right = sz-1;
 
 
	while(left<right)
	{
		int tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;
		left++;
		right--;
	}
}

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

*
思路：题目比较简单，请参考代码以及注释
*/
 
 
#include <stdio.h>
 
 
int main()
{
	int arr1[10] = {0};
	int arr2[10] = {0};
	int i = 0;
 
 
	printf("请输入10个数字:>");
	for(i=0; i<10; i++)
	{
		scanf("%d", &arr1[i]);
	}
	printf("请输入10个数字:>");
	for(i=0; i<10; i++)
	{
		scanf("%d", &arr2[i]);
	}
	//交换
	for(i=0; i<10; i++)
	{
		int tmp = arr1[i];
		arr1[i] = arr2[i];
		arr2[i] = tmp;
	}
	
	return 0;
}