【C语言数组】一、二维数组&冒泡排序

---

1. 一维数组的创建和初始化

如果说想要定义10个相同类型的变量，单个定义的话会太麻烦，因此下面就引出了数组的概念。

1.1 一维数组的创建

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

数组的创建方式：

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

//整形数组
int arr[10];
//字符型数组
char ch[5];
...
//创建的语法形式

1.2 数组的初始化

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

//这种叫做不完全初始化
//剩余的元素默认初始化为0
int arr1[10] = {1,2,3};
//只初始化，不指定元素大小
//元素大小会根据后面初始化的元素个数来确定大小
int arr2[] = {1,2,3,4};
int arr3[5] = {1，2，3，4，5}；
char arr4[3] = {'a',98, 'c'};
char arr5[] = {'a','b','c'};
char arr6[] = "abcdef";

注意：如果你想让它是个字符串，末尾必须是以\0结束，否者不能以字符串的形式来打印它。

1.3 一维数组的使用

对于数组的使用我们之前介绍了一个操作符： [] ，下标引用操作符。它其实就数组访问的操作符。

我们来看代码：

int main()
{
	int arr[10] = {0};//数组的不完全初始化
    //计算数组的元素个数
    int sz = sizeof(arr)/sizeof(arr[0]);
	//对数组内容赋值,数组是使用下标来访问的，下标从0开始。所以：
	int i = 0;//做下标
	for(i=0; i<10; i++)
	{
		arr[i] = i;
	} 
	//输出数组的内容
	for(i=0; i<10; ++i)
	{
		printf("%d ", arr[i]);
	}
	//0 1 2 3 4 5 6 7 8 9
	return 0;
}

注意:
1. 数组是使用下标来访问的，下标是从0开始。
2. 数组的大小可以通过计算得到。

int arr[10];
//总数组大小除以数组第一个元素大小就是数组元素个数
int sz = sizeof(arr)/sizeof(arr[0]);

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

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

仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。

由此可以得出结论：数组在内存中是连续存放的。

---

2. 二维数组的创建和初始化

一维数组是一组相同类型元素的集合，二维数组也是如此，但是如果想存放一组一组的数据，这时就可以考虑二维数组。

2.1 二维数组的创建

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

//数组类型 数组名
//后面两个方括号代表几行几列

2.2 二维数组的初始化

1 2 3 4
2 3 4 5
3 4 5 6
上面三行四列的元素如何放到二维数组呢？

//直接一口气存放到二维数组中
int arr[3][4] = {1,2,3,4,2,3,4,5,3,4,5,6};
//因为是已经限定了行和列
//先给第一行存放四个元素
//然后继续寻找四个元素放到第二行和第三列。

如果想把特定的元素分别放入不同行该怎么初始化？

比如说 1 2 3 4 5 6放入arr[3][4]：

int arr[3][4] = {{1,2},{3,4},{5,6}};
//这时就需要把每两个元素用一个大括号扩起来

注意：不完全初始化也是用0补齐。

二维数组是否可以只初始化，省略行和列？

int arr[][3] = {{1,2,3},{4}};

这里需要注意的是，二维数组可以省略行，因为它可以根据后面的列数来推断行，比如上面就是2行，但是不可以省略列，省略列就没办法算出行数。

2.3 二维数组的使用

和一维数组相似，二维数组的行和列的下标也都是从0开始的：

通过行和列的下标就可以很好的找到想找的元素。

把每个元素打印出来：

int main()
{
	int arr[3][4] = { 1,2,3,4,2,3,4,5,3,4,5,5 };

	//第i行
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		//第j列
		int j = 0; 
		for (j = 0; j < 4; j++)
		{
			//第i行j列的元素
			printf("%d ", arr[i][j]);
		}
		//打印完一行元素换行
		printf("\n");
	}
	return 0;
}

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

二维数组在内存里并不是像上面那样一行一列的去存储，其实和一维数组相同，都是连续存放的。

可以看出一行每个元素差了四个字节，换行后也是差四个字节，因此二维数组在内存中也是连续存放的。

---

3. 数组越界

数组的下标是有范围限制的。
数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。

所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。

C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，

所以写代码时，最好自己做越界的检查。

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

越界访问打印了随机值。

---

为了避免这种错误，可以用sizeof(arr) / sizeof(arr[0])来计算数组元素个数。

4. 数组作为函数参数

4.1 冒泡排序

往往我们在写代码的时候，会将数组作为参数传个函数，比如：我要实现一个冒泡排序算法函数

将一个整形数组按照升序（从小到大）排序。

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

学了函数就把它写成函数的形式：

//英文，记不住就拼音
//bubble_sort(arr);
mao_pao(arr);

对数组进行排序，首先要把数组名作为实参传过去，不需要加上[]。（数组传参实际上传过去的是首元素的地址），

接来下看一下数组传参的区别：

数组形参接收有两种写法：
1. 数组
2. 指针

//形参时数组的形式
//这是比较直观的写法，传上来输组，数组再接收
//注意这里就需要带上[]，因为是数组
void mao_pao(int arr[])
{

}

//指针的写法
//实际上传的是首元素的地址，用指针变量来接收
void mao_pao(int* arr)
{

}

冒泡排序的核心思想：
相邻两个元素进行比较，如果比较出的大小不满足顺序，就交换两个元素的顺序。

上面的数组，先看前两个相邻的元素9和8不满足升序顺序，因此需要交换顺序，然后第二个和第三个元素比较…以此类推。

两两比较完，最大的元素就到了最后，这只是一趟冒泡排序，一趟确定一个最大的元素。
接下来需要排序的数据就是8~0，不用管9了，因为它已经是最大的元素。

这又是一趟排序，一趟就让一个元素来到它最终出现的位置上。

因为是两两交换的形式，把九个元素交换到它应该出现的位置上，那剩下的一个就已经也在它出现的位置上了，因此，10个元素需要9趟冒泡排序，n个元素就是n-1趟。

4.1.1 冒泡函数的错误设计以及修改

代码实现：

void mao_pao(int* arr)
{
    //趟数
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < sz - 1; i++)
	{
		//一趟冒泡排序
		//10个元素两两比较有9对
		//第一趟就搞定了一个最大的元素
		//下趟9个元素就比较8对  
		//8个元素比较7对 
		//...以此类推

		//判断条件根据i的增加来减少比较对数
		for (int j = 0; j < sz - 1 - i; j++)
		{
			//第j个元素和j+1个元素进行比较
			//不满足就交换位置
			if (arr[j] > arr[j + 1])
			{
				int t = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = t;
			}
		}
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	mao_pao(arr);
	
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

最后打印的结果：

这里出问题了，为什么冒泡排序没有排序？

调试看哪里出了问题：

这里求元素个数应该10，但是却求出来个1，一减一循环压根就没进去，所以没排序，在函数里求元素个数搞不定。

这是因为：

数组名本质上是数组首元素地址，形参部分是用指针变量来接收。
所以sizeof计算的不是数组大小，而是一个指针的大小（x86环境下指针大小是4），一个整形元素的大小也是4，4除以4就是1了，这就是这个循环的问题。

解决办法是，在主函数内部求得数组大小，再作为参数传到函数里。

void mao_pao(int* arr, int sz)
{
	for (int i = 0; i < sz - 1; i++)
	{
		for (int j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int t = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = t;
			}
		}
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	mao_pao(arr, sz);

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

一定要注意求数组元素个数要在主函数里求。

4.2 数组名是什么

数组名一定都是首元素地址吗？

int main()
{
	int arr[10] = { 0 };
	//直接打印数组名地址
	printf("%p\n", arr);
	//打印首元素地址
	printf("%p\n", &arr[0]);

	return 0;
}

这里可以看出两个地址相同，所以数组名就是首元素地址。

如果数组名是首元素地址，那么：

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

既然是首元素地址，为什么输出的是40？

注意有两个例外：

1. sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组，单位是字节。
2. &数组名，取出的是整个数组的地址。&数组名，数组名表示整个数组。

除此1,2两种情况之外，所有的数组名都表示数组首元素的地址。

拿第二个举个例子：

int main()						 
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	//&数组名
	printf("%p\n", &arr);
	return 0;
}

和上面两个有什么区别？

和上面两个地址相同，所以&数组名取出的整个数组的地址，也是第一个元素的地址，那有什么区别呢？

int main()						 
{
	int arr[10] = { 0 };
	//arr就是首元素的地址
	printf("%p\n", arr);
	printf("%p\n", arr+1);
	printf("---------\n");
	//首元素的地址
	printf("%p\n", &arr[0]);
	printf("%p\n", &arr[0]+1);
	printf("---------\n");
	//数组的地址
	printf("%p\n", &arr);
	printf("%p\n", &arr+1);

	return 0;
}

上图可以发现arr和首元素地址相同，并且+1之后也是相同的，跳过了4个字节，也就是一个元素。而&数组名虽然一样但是+1之后跳过了40个字节（28是十六进制要转成十进制），跳过了整个数组。

所以数组的地址和数组首元素的地址也是有区别，虽然值一样但意义完全不一样。

二维数组的数组名表示的也是首元素地址：

int arr[3][4] = {0};

不是 0 0的那个元素，而是要把二维数组想象成一维数组，每一行就是它的一个元素，所以二维数组的数组名是第一行的地址。

地址+1跳过了16个字节也就是一行（十六进制5->6）。

求二维数组的行和列：

---

总结

以上就是今天要讲的内容，本文仅仅简单介绍了本人在学习一二维数组和冒泡排序算法方面的知识与见解。
本篇的重点就在于一二维数组的创建、使用和在内存中的存储以及数组作为函数参数方面的内容，很重要得好好地掌握。

最后感谢大家的阅读！

下期：三子棋