【C语言】——二维数组学习

二维数组的创建和初始化

int main() {
	int arr[3][5] = {1,2,3,4,5,6,7,8,9,10};//在创建的时候，给值，叫初始化
    
	int arr[3][5] = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10 } };//在创建的时候，给值，叫初始化
    
	int arr[][4] = { { 1, 2, 3, 4 }, { 2, 3, 4, 5 } };//也是正确的写法
    
	int arr[2][] = { { 1, 2, 3, 4 }, { 2, 3, 4, 5 } };//错误的写法，二维数组可以省略行下标 ，但不能省略列下标
    
}

二维数组遍历

int main() {
	int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

二维数组在内存中的存储

int main() {
	int arr[3][4] = { 0 };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
		}
	}
	return 0;
}

相邻元素之间相差4个字节。 说明二维数组在内存中的存储也是连续的。

证明二维数组在内存中是连续存放的：

int main() {
	int arr[3][4] = {1,2,3,4,2,3,4,5,3,4,5,6};
	int* p = &arr[0][0];
	int i = 0;
	for (i = 0; i < 12; i++)
	{
		printf("%d ", *(p + i));
	}
}

打印二维数组

void print(int arr[3][5], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

int main()
{
	int arr[3][5] = {1,2,3,4,5,2,3,4,5,6,3,4,5,6,7};
	print(arr, 3, 5);//打印二维数组arr

	return 0;
}

数组传参

冒泡排序：

冒泡排序：比较相邻的元素。如果第一个比第二个大，就交换他们两个。

标准的零分，经典的错误的代码：

void bubble_sort(int arr[]) {
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 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 arr[10] = { 0,1,2,3,4,5,6,7,8,9};
	//排序成升序
	//数组传参的时候
	//数组名是首元素的地址
	//arr == &arr[0]
	bubble_sort(arr);
	return 0;
}

在此函数中，下面两个写法是相同的
void bubble_sort(int arr[]);
void bubble_sort(int *arr);

在此计算中 ，函数里

sz = sizeof(arr) / sizeof(arr[0]);

sz的结果为1.（因为数组传参时，传的是arr的首元素地址，arr只是首元素的地址，大小为4）

正确的代码：

把

sz = sizeof(arr) / sizeof(arr[0]);

放在主函数里。

void bubble_sort(int arr[],int sz) {
	
	int i = 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 arr[10] = { 9,8,7,6,5,4,3,2,1,0};
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr,sz);
	return 0;
}

简单优化代码：

假设

int arr[10] = {0,1,2,3,4,5,6,7,8,9};

尽管代码已经有序，但在上述代码中仍需要循环规定的次数。
在优化代码中引入flag，当本次的所有 j 循环中没有发生交换时，说明函数已经有序，直接break跳出循环。

void bubble_sort(int arr[],int sz) {
	
	int i = 0;
	for (i = 0; i < sz - 1; i++) {
		int j = 0;

		int flag = 1;//假设已经有序

		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;
				flag = 0;
			}
		}
		if (flag == 1) {
			break;
		}
	}
}

void print_arr(int arr[], int sz) {
	int i = 0;
	for (i = 0; i < sz; i++) {
		printf("%d ", arr[i]);
	}
}

int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9};
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr,sz);
    print_arr(arr, sz); 
	return 0;
}

比较数组名和首元素地址：

int main()
{
	int arr[5] = { 1, 2, 3, 4, 5 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	printf("%d\n", *arr);//1

	return 0;
}

注意：

sizeof（）

int main()
{
	int arr[10] = { 0 };
	printf("%d\n", sizeof(arr));//40
	int sz = sizeof(arr) / sizeof(arr[0]);//10
	return 0;
}


//数组名是数组首元素的地址
//但是有2个例外：
//1. sizeof(数组名) - 数组名表示的整个数组，不是首元素的地址.sizeof(数组名)计算机的是整个数组的大小
//2. &数组名，数组名表示整个数组，这里取出的是整个数组的地址！！！
//除此之外，所有 的数组名都是首元素的地址

二维数组求元素个数：

int main()
{
	int arr[3][4] = {0};
	int sz = sizeof(arr) / sizeof(arr[0][0]);
	printf("%d\n", sz);
	return 0;
}

补充：

int main() {
	int arr[4] = { 1,2,3,4 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	printf("%p\n", &arr);
}

前两个是首元素的地址，最后一个是整个数组的地址。（虽然结果一样，但表达的内涵不同），如下图

int main() {
	int arr[4] = { 1,2,3,4 };
	printf("%p\n", arr);
	printf("%p\n", arr + 1);

	printf("%p\n", &arr[0]);
	printf("%p\n", &arr[0] + 1);

	printf("%p\n", &arr);
	printf("%p\n", &arr + 1);

}