C语言基础之数组【冒泡排序算法】

• • 一维数组
  • • 数组的初始化
    • 数组大小的计算
    • 下标引用操作符的使用
    • 数组的遍历打印
    • • 打印元素
      • 打印地址
    • 冒泡排序算法
  • 二维数组
  • • 二维数组的创建
    • 二维数组的遍历打印
    • • 数组越界
  • 数组传参机制
  • • 数组
    • • 二维数组数组名的理解
      • 二维数组计算列与行

数组是一组类型相同的元素的集合，在C99之前数组的大小是常量，在C99之后为了支持变长数组，数组大小可以为变量，但是只能在C99编译器进行编译,如：gcc等等。
数组分为一维数组和二维数组

一维数组的创建格式为 ：type_t arr_name [const_n] – 类型 数组名 【数组大小】

在一维数组创建的时候指定数组里面的元素称为数组初始化。初始化的格式也有好几种。

下面就是其中一种初始化格式 – 不完全初始化，指定了数组大小，为数组前三位赋值，然后后面的数组编译器默认赋值为 0；

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

这一种是没有指定数组大小进行初始化，为该数组赋值前 3 位，数组大小就是 3，元素个数就是数组大小。

int arr2[] = { 1 , 2 ,3 }

将字符串直接赋值给数组，该数组存放的值为：1 2 3 0 0 0 0 0 0 ；123的后端会有一个 ‘’ ，该数组的大小要算上 ‘’，所以值为 4。

char arr1[10] = "123"

数组我们要计算它的大小一般采用 sizeof 函数，比如说 int arr[10] 该数组我们要计算它的大小可以为 ：int sz = sizeof(arr) / sizeof(arr[0])；通过整个数组的大小除以数组里面一个元素的大小来求出。

在数组中我们要取出数组内的某一元素，我们可以用下标引用操作符来取出 – ‘[ ]’ 。
在数组内是用下标来定位数组的每一个元素，比如说：int arr2[] = { 1 , 2 ,3 };
该数组，元素 1 2 3 对应的下标为 0 1 2，数组的下标是用 0 开始算起的。
所以说 我们想取出该数组内的元素 1 2 3，可以用 arr[0] arr[1] arr[2]来实现，
数组的最后一个元素下标为（数组大小 - 1）

我们想将数组内的元素打印到屏幕上，可以用循环遍历打印来实现，

	//数组输出----遍历
	for (int i = 0; i < sz; i++) {
		printf("%d n", arr[i]);
	}

i 为数组内元素的下标，将下标为 i 的元素一个一个的打印出来，最终
i < ( 数组的大小 - 1)，打印出数组内所有元素。

与数组遍历打印元素的原理一样，将数组内各元素的地址遍历打印出来，我们可以发现 arr[i] 与 arr[i + 1] 地址相差4 ，
因为一个元素是存放在4个字节中的 。该元素的地址就是该元素第一个字节的地址 。
由此可见，随着下标增长，数组的地址是递增的 ，在一维数组中元素是连续存放的，

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

如果我们想将一个乱序的数组按照从小到大或者从大到小重新排序，我们可以考虑使用冒泡排序法：
如果我们想控制从小到大或者从大到小的顺序：
if (arr[j] > arr[j + 1])在这里的if语句显得尤为关键，如果 里面是大于号 则 该数组从小到大来进行排序，如果里面是小于号 则 该数组从大到小来进行排序。

void bubble_sort(int arr[] , int sz) {//形参int arr[] ，方括号内可以写也可以不写，
	int i = 0;
	int j = 0;
	int tmp = 0;
	for (i = 0; i < sz - 1; i++) {
		for (j = 0; j < sz - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}			
		}
	}
}
int main() {
	//把数组的数据排成升序
	int arr[] = { 9,8,7,6,5,4,50,20,3,2,1,0 };
	//0 1 2 3 4 5 6 7 8 9
	//冒泡排序算法
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr , sz);
	for (int n = 0; n < sz ; n++) {
		printf("%d ", arr[n]);
	}
	return 0;
}

二维数组在我的理解下，其实就是一维数组的数组，元素为一维数组，
比如说 ： int arr1[3][4] 该二维数组其实就是 3 个大小为 4 的一维数组组成的，该数组有 3 行 4 列

二维数组创建 行可以省略，列不可以省略
例： arr[ ][2] = {1，2，3，4，5}第一行存放 1 2 ，第二行存放 3 4 第三行存放 5 0 ,列没有省略可以有基础的存放
如果列省略，行没有省略，这样的话元素在该数组存放就没有了基础，无法存放。

二维数组的遍历打印得用到循环嵌套，两个for循环。i 代表的是行数（多少个一维数组），j 代表的是列数（一维数组里面有多少个元素） 。二维数组下标访问跟一维数组是一样的。

	//二维数组的遍历
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 4; j++) {
			printf("%d ", arr1[i][j]);
			printf("n");

		}
	}

在二维数组下标超过数组的下标访问限制，称为数组越界，

int main() {
	int arr[] = { 1,2,3,4,5,6 };
	printf("%d ", arr[6]);//数组越界
	//下标访问超过数组的下标范围限制 
	//编译器会打印随机值
	return 0;
}

数组传参形参有两种写法，
1.数组
2.指针

形参是数组形式，
并不是重新创建一个数组。
数组名本质上是数组首元素地址，函数通过传递过来的元素首地址找到该数组。
地址按道理应该用指针来接收，所以 arr 这里看似是数组，其实是首元素地址。

void bubble_sort(int arr[] , int sz) {
}

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

数组名可以表示首元素地址，但是也有两种情况意外 :
1.&数组名 这里的数组名表示的是整个数组，取出的是整个数组的地址
2.sizeof(arr) 这里表示整个数组，计算的是数组大小，单位字节。

	int arr[10];
	printf("%pn", arr);//数组名可以表示首元素地址，但是也2有意外
	printf("%pn", arr + 1);//首元素地址
	printf("===================n");
	printf("%pn", &arr[0]);
	printf("%pn", &arr[0] + 1);//首元素地址
	printf("===================n");
	
	//&数组名 这里的数组名表示的是整个数组，取出的是整个数组的地址
	printf("%pn", &arr);
	printf("%pn", &arr + 1);//首元素的地址加上整个数组的大小
	printf("%dn", sizeof(arr));
	//这里表示整个数组，计算的是数组大小，单位字节

二维数组的数组名也表示首元素的地址，表示第一行的数组（第一个一维数组）int arr[3][4]; printf("%pn" , arr); 这里打印的是第一个一维数组的地址，然而一维数组的地址打印出来是第一个元素的地址。

整个数组大小 / 第一行数组大小 = 多少行

printf("%dn", sizeof(arr) / sizeof(arr[0]));//整个数组大小 / 第一行数组大小 = 多少行

第一行数组大小 / 第一行第一个元素大小 = 多少列

printf("%dn", sizeof(arr[0]) / sizeof(arr[0][0]));//第一行数组大小 / 第一行第一个元素大小 = 多少列