C语言：数组的详细介绍

一、一维数组的创建和初始化

1.1 一维数组的创建

  数组是由一组具有相同类型元素的集合。

一维数组的创建方式：
类型声明符 数组名[常量表达式]

type   arr_name   [const_n];
type 		是指数组的元素类型
arr_name 	是数组名
const_n 	是一个常量表达式，用来指定数组的大小

 
一维数组正确创建的实例：

//代码1
int arr1[10];
char arr3[100];
float arr4[99];
double arr5[20];

 
一维数组错误创建的实例：

//代码2
int count = 10;
int arr2[count];//[] 中要给一个常量才可以，不能使用变量

  总结：数组创建，在C99标准之前， [ ] 中要给一个常量才可以，不能使用变量。 可以在[ ]放变量的前提是在C99标准支持了变长数组。

 
 

1.2 一维数组的初始化

  数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）

例如：

int arr[10] = {1,2,3,4,5,6,7,8,9,10};//完全初始化
int arr[10] = { 1,2,3,4,5 };//不完全初始化 没有被初始化的会自动为 0

int arr2[] = { 1,2,3,4,5 };//数组长度会根据元素定义

char ch1[5] = {'b', 'i', 't'}; //字符型数组未初始部分为'\0'  b i t \0 \0
char ch2[] = { 'b', 'i', 't' }; 						  // b i t

char ch3[5] = "bit";	//b i t \0 \0
char ch4[] = "bit";		//b i t \0

char ch5[] = "bit";				//[b i t \0]
char ch6[] = { 'b', 'i', 't' };	//[b i t]

  总结：数值型数组未被 “初始化” 的会自动初始化为 0
     字符型数组未被 “初始化” 的会自动初始化为 ‘\0’
     指针型数组未被 “初始化” 的会自动初始化为 NULL
 
 数组的元素个数可以根据初始化的内容来确定。
 字符串 “abc” 这种c的后面会有一个结束标志符 \0 ，而 { ‘a’ , ‘b’ , ‘c’ } 这种c后面不会有 ，如下图：

 
 

1.3 一维数组的使用

  引用数组元素的表示形式： 数组名[下标]

int main()
{
	int arr[10] = { 0 };//数组的不完全初始化
	arr[4] = 5;//[] - 下标引用操作符

	int i = 0;
	printf("%d\n", sizeof(arr));	//整个数组的大小
	printf("%d\n", sizeof(arr[0]));	//一个元素的大小
	printf("-------------\n");

	//计算数组的元素个数=数组的大小/一个元素的大小
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		arr[i] = i;
	}
	for (i = 0; i < 10; ++i)//输出数组的内容
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

 总结：数组是使用下标来访问的，下标是从0开始。
    数组的大小可以通过计算得到。

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

 
 

1.4 一维数组在内存中的存储

  接下来我们探讨数组在内存中的存储

int main()
{
	//printf("%x\n", 0x12);
	//printf("%p\n", 0x12);

	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	for (i = 0; i < 10; i++)	//打印每个元素的地址
	{
		printf("&arr[%d] = %p\n", i, &arr[i]);
	}
	printf("\n");

	int* p = arr;//数组名是数组首元素的地址
	for (i = 0; i < 10; i++) //通过首元素地址找到其他元素
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

 总结：仔细观察输出的结果，随着数组下标的增长，元素的地址，也在有规律的递增。由此可以得出结论：数组在内存中是连续存放的。

 
 

二、二维数组的创建和初始化

2.1 二维数组的创建

//数组创建
int arr[3][4];
char arr[3][5];
double arr[2][4];

 
 

2.2 二维数组的初始化

int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12}; 	//完全初始化
int arr[3][4] = { 1,2,3,4,5,6,7};				//不完全初始化 - 后面补0
int arr[3][4] = { {1,2}, {3,4} ,{4,5} };		//1,2,0,0,3,4,0,0,4,5,0,0
int arr[][4] = {{2,3},{4,5}};//二维数组如果有初始化，行可以省略，列不能省略

 总结：
1.二维数组的 { } 初始化可以写成和一维数组一样
2.不完全初始化 - 后面补0
3.二维数组如果有初始化，行可以省略，列不能省略 (为什么列不能省略？因为系统要根据列可以确定行，如int arr[ ][4] = {1,2,3,4,5,6,7,8,9,10,11,12}; 系统可以根据列是4确定3行，每行4个元素。

 
 

2.3 二维数组的使用

int mian()
{

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

 
 

2.4 二维数组在内存中的存储

int main()
{
	int arr[][4] = { {1,2}, {3,4} ,{4,5} };
	int i = 0;
	int j = 0;
	int* p = &arr[0][0];

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

	return 0;
}

 总结：二维数组在内存中也是连续存储的。

 
 

三、数组越界

数组的下标是有范围限制的。
数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。

例如：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int n = 0;
	for (n = 0; n <= 12; n++)
	{
		printf("%d\n", arr[n]);//当n等于10的时候，就已经越界访问了
	}
	return 0;
}

  总结：越界访问结果是随机的。二维数组的行和列也可能存在越界。

 
 

四、数组作为函数参数（冒泡排序）

  我们在写代码有时候会将数组作为参数传给函数，比如：我要实现一个冒泡排序（将一个整形数组排序）

void bubble_sort(int arr[], int sz)//形参arr本质是指针
{
	//确定趟数
	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[] = { 9,8,7,6,5,4,3,2,1,0 };
	
	//计算数组元素个数
	int sz = sizeof(arr) / sizeof(arr[0]);

	bubble_sort(arr, sz);//数组传参的时候，传递的其实是数组首元素的地址

	return 0;
}

 

代码优化：要是数组里的元素本身就是排好的顺序我们要怎么去优化？

当数组本身就已经排好顺序，我们只需要判断他的元素有没有交换，如果一次都没有交换，那就证明数组本身就已经排好了顺序，然后我们break跳出循环即可；

void bubble_sort(int arr[], int sz)//形参arr本质是指针
{
	//确定趟数
	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;
		}
	}
}
int main()
{
	int arr[] = { 0,1,2,3,4,5,6,7,8,9 };

	//排序为升序 - 冒泡排序
	//计算数组元素个数
	int sz = sizeof(arr) / sizeof(arr[0]);

	bubble_sort(arr, sz);//数组传参的时候，传递的其实是数组首元素的地址

	return 0;
}

  总结 :
1、数组传参的时候，传递的其实是数组首元素的地址
2、在进行排序的时候，10个数字最多交换9次，所以算出数组大小 sz-1 确定交换多少次。（也就是代码里面的趟数）
3、每一躺排序都会将一个数按照代码逻辑排好，为了提高代码效率，代码中的 sz-1-i 意思是：（sz-1）最多排九次，每排好一次就 -i 不用管最后一个数字，
所以写成（sz-1-i）
4、当数组本身就已经排好顺序，我们只需要判断他的元素有没有交换，如果一次都没有交换，那就证明数组本身就已经排好了顺序，然后我们break跳出循环即可；