铁汁们，今天给大家分享一篇数组及详解冒泡排序，来吧，开造⛳️

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

一维数组的创建和初始化

一维数组的创建

一维数组在创建时，未给出确定的数组大小值，则该数组必须得初始化，数组的大小根据初始的内容来确定，eg:int arr[]={1,2,3,4,5,6}。若不初始化，则编译器会报错。

一维数组的初始化

由于博主在前面给铁汁分享函数栈帧的创建与销毁可知：

局部变量或者定义在函数体内的数组 是在栈上开辟空间，如果不初始化，根据函数栈帧的知识可知，则其值默认为随机值。

数组初始化的定义：数组在创建的同时给数组内容赋予初始值。eg:char arr[6]=“abcde”;

一维数组的应用

访问数组中的元素，要使用[ ]下标引用操作符，操作数为数组名、数组下标值。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);  //求任意类型元素总个数，sizeof为操作符
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]); //访问数组元素，下标引用操作符
	}
	return 0;
}

数组是通过下标来进行访问的，下标值从0开始。

求数组元素总个数： int sz = sizeof(arr) / sizeof(arr[0])，sizeof为操作符，操作数是类型或者变量，计算的是类型或者变量占内存的大小，单位为字节。

一维数组在内存中的存储

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	int sz = sizeof(arr) / sizeof(arr[0]); 
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("arr[%d]=%p\n",i, &arr[i]); 
	}
	return 0;
}

由图可知随之数组下标的增长，数组下标也是成一定规律进行增长，相邻两个元素地址相差4个字节。

二维数组的创建和初始化

二维数组的创建

二维数组在创建时，行可以省略，但列不能省略，若要省略行，则二维数组必须得要初始化，行的值根据初始化的内容来确定。

二维数组的初始化

二维数组初始化的定义：数组在创建的同时给数组内容赋予初始值。eg:int arr[4][5]={{1,2},{3,4}};

二维数组的应用

二维数组与一维数组相同，也是通过下标来进行访问。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int arr[4][3] = {{0,1,2},{3,4,5},{6,7,8},{9,10,11}};
	int i = 0;
	for (i = 0; i <4; i++)
	{
		int j = 0;
		for (j = 0; j < 3; j++)
		{
			printf("%d ",arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

二维数组在内存中的存储

%p:打印地址，参数变量要加取地址操作符&。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int arr[4][3] = {{0,1,2},{3,4,5},{6,7,8},{9,10,11}};
	int i = 0;
	for (i = 0; i <4; i++)
	{
		int j = 0;
		for (j = 0; j < 3; j++)
		{
			printf("%p\n",&arr[i][j]);
		}
	}
	return 0;
}

由图可知，随着下标的增长，地址成一定的规律增长（相邻两元素地址相差4个字节），即：二维数组在内存中是连续存放的。

数组越界问题

数组下标是有范围限制的。

c语言标准规定，数组下标从0开始，若数组中有n个元素，则最后一个元素对应的下标值不超过n-1，即：数组下标值的范围为0到n-1,若小于0或超过n-1，就是数组的越界访问啦~，起始就是超出了数组的合法空间（本身向内存申请空间。

c本身是不做下标越界的检查，编译器也不一定会报错，但编译器不报错，并不说明代码就是正确的，作为一名程序员，我们应该要具备在写代码时，自己做好数组越界检查。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i <= sz; i++) //此处不能等于sz，造成了数组越界
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

一维数组、二维数组行和列均有越界的可能性。

数组作为函数参数

数组名的含义及特殊两个例子

通常情况下，数组名是首元素的地址（两个例外）
1 sizeof（数组名）：计算的是整个数组的大小，单位是字节，sizeof内部单独放一个数组名，数组名表示整个数组
2.&数组名：取出的整个数组的地址，&数组名,数组名表示整个数组。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int arr[5] = { 0,1,2,3,4 };
	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;
}

冒泡排序详解

适用条件：整形数组进行升序排序（也适用于数组中含有相同元素在不同位置处的升序排序）。

实现思想：相邻两元素两两进行比较、采用两层for循环（第一层for循环控制总趟数、第二层for循环控制每一趟两相邻元素之间要比较的对数），每一趟都可以让某一个元素到达其最终所在的位置处。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
void Maopao(int arr[10], int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)//控制要排序的总趟数
	{
		int flag = 1;//假设进行每一趟排序之前该数组已经有序，无需依次把每个元素进行比较，效率高
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++) //控制每一趟两相邻元素之间要比较的对数
		{
			if (arr[j] > arr[j + 1])
			{
				flag = 0;  //说明该数组此时并未达到是有序的
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
		if (flag == 1)
		{
			break;  //该数组为有序数组，直接跳出循环，无需进行比较，效率提高
		}
	}
}
int main()
{
	int arr[10] = { 10,9,4,7,6,5,2,3,1 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]); //计算数组中元素的总大小，切不可放在冒泡函数实现中，不然sz值为1（4/4=1）
	Maopao(arr, sz); //数组作为参数传参时，传的是数组名，首元素的地址，为4个字节，arr==int* arr
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]); //打印
	}
	return 0;
}

扫雷与多子棋的实现

铁子们~此处代码的实现博主已经在其他篇博客详细讲解了，请铁铁们点击此链接观看呦扫雷实现详解、三子棋及多子棋的实现。

铁铁们，数组及详解冒泡排序讲解就到此结束啦，请动动你们的手给作者点个👍鼓励吧，你们的鼓励就是我的动力✨