2.2 二维数组的初始化

int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};
char arr[3][4] = {"abc","def","qwe"};

第二种初始化方式与第一种不同，第一种方式是每行存满后进入下一行，而第二种方式则是第一行存1、2，第二行存4、5，其余位置以0补齐。同理，第四种初始化原理和第二种相同，每个" "代表不同行，每行以'\0'为结尾。

注意:二维数组的初始化行可以省略，列不能省略！

#include <stdio.h>
int main()
{
     int arr[3][4] = {{1,2,3},{4},{5,6}};
     int i = 0;
     for(i=0; i<3; i++)//行数
     {
         int j = 0;
         for(j=0; j<4; j++)//列数
         {
         printf("%d ", arr[i][j]);
         }
        printf("\n");
     }
     return 0;
 }
打印结果为   1 2 3 0 
            4 0 0 0    
            5 6 0 0

#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
 ? ?int i = 0;
 ? ?for(i=0; i<=10; i++)
 ?  {
 ? ?    printf("%d\n", arr[i]);//当i等于10的时候，越界访问了
 ?  }

     return 0;
}

输出结果

?超出范围后就出现了随机值。

注意:C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，所以程序员写代码时，最好自己做越界的检查。

4.冒泡排序

图解

void 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;
		}
	}
}
#include<stdio.h>
int main()
{
	int i;
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	
	Sort(arr, sz); 
	for (i = 0; i < 10; i++)
	{
		printf("%d", arr[i]);
	}
	return 0;
}

有的人会疑惑，sz为什么也要作为参数传过去，在函数内部算不就行了。实际上arr在主函数里，sizeof（arr）中arr代表的是整个数组，当你把数组传参给函数时，函数是以指针的方式接收，相当于是传了个地址过去，这样就会导致在自定义函数内部计算sizeof（arr）是4个字节（以32bit为例），再除每个元素的大小，算出来是1个元素，这就与实际不符合了。

这里的flag是为了提升效率的，如果一组数本来就是有序的，你再进行排序就多此一举了，所以在这里增加个判断是否有序，如果有序直接跳出去，避免无用功，造成程序效率低下。

在这里总结一下：

数组名就是首元素的地址

有2个例外：

1. sizeof(数组名)，这里的数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小。

2. &数组名，这里的数组名表示整个数组，取出的是数组的地址。

我们可以进行验证

虽然三个地址都是一样的，但意义不一样。第一个和第二个代表都是首元素的地址，而第三个表示的是整个数组的地址。