C语言 - 数组

Posted 2021-06-11 跳动的bit

文章目录

• 前言
• 一、一维数组的创建和初始化
• 二、一维数组的使用
• 三、一维数组在内存中的存储
• 四、二维数组的创建和初始化
• 五、二维数组的使用
• 六、二维数组在内存中的存储
• 七、数组名
• 八、数组作为函数参数
• • 1.冒泡排序
• 九、字符数组
• 十、数组的应用实例1：三子棋
• 十一、数组的应用实例2：扫雷游戏

前言

在本章将继续学习C语言初阶的知识 —— 数组。之前的学习过程中，也大致了解了什么是数组 —— 相同类型元素的集合。数组分为一维数组、二维数组、三维数组(多维数组)… … 。这里主要了解和学习的是一维数组和二维数组。在学习完数组的相关知识后，会有2个小游戏来练手

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

• 1.一维数组创建的格式
  数据类型 + 数组名[元素个数];
  注意[ ]里是一个常量表达式；在一维数组初始化时可以不指定大小
• 2.一维数组的初始化(完全初始化、不完全初始化)
• 3.初始化为0
• 4.变长数组

int main()
{
	//一维数组的创建：
	int arr[8];//这是一个数组，存储8个整型类型的元素
	char ch[5];//这是一个数组，存储5个字符类型的元素

	//-----------------------------------------------------------
	//变量的初始化：(创建的同时给赋值)
	int a = 10;
	//一维数组的初始化：
	int arr1[10] = {1,2,3,4,5,6,7,8,9,10};//完全初始化
	int arr2[10] = {1,2,3,4,5};//不完全初始化，后面的5个元素会被默认初始化为0
	//初始化为0时arr3和arr4是一样的
	int arr3[10] = {0};//不完全初始化：只初始化了第1个元素，剩下的会被默认初始化为0
	int arr4[10] = {0,0,0,0,0,0,0,0,0,0};//完全初始化
	
	//------------------------------------------------------------
	//一维数组在初始化时可以不指定大小
	int arr5[] = {1,2,3,4,5};
	//同int arr5[5] = {1,2,3,4,5};
	
	//-----------------------------------------------------------
	//测试数组的大小能否是变量(测试平台VS2017 && Windows)
	//这种以变量作为元素大小的数组叫做变长数组 —— C99语法支持
	int n = 8;
	//int arr[n];//err：应输入常量表达式，显然我的VS2017不支持C99
	return 0;
}

二、一维数组的使用

• 打印一维数组的元素。对于数组的使用我们之前介绍了一个操作符：[ ] 下标引用操作符；对于数组下标是从0开始的

#include<stdio.h>
int main()
{
	int arr[10] = {0};
	arr[4] = 5;
	int i = 0;

	printf("%d\\n", sizeof(arr));//40
	printf("%d\\n", sizeof(arr[0]));//4
	int sz = sizeof(arr) / sizeof(arr[0]);//数组总大小/数组1个元素大小可以得到数组元素个数
	for(i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);//0 0 0 0 5 0 0 0 0 0
	}
	return 0;
}

三、一维数组在内存中的存储

• 1.一维数组在内存中是连续存放的
• 2.随着数组下标的增长，地址是由低到高变化的

#include<stdio.h>
int main()
{
	int arr[10] ={0};
	int i = 0;
	for(i = 0; i < 10; i++)
	{
		printf("arr[%d] = %p\\n", i, &arr[i]);
	}
	return 0;
}

输出结果：

• 3.一维数组在内存中是连续存放的，所以在拿到数组的起始位置时就能找到整个数组

#include<stdio.h>
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int* p = arr;//.数组名是首元素地址
	int i = 0;
	for(i = 0; i < 10; i++)
	{
		printf("%d ", *p);//1 2 3 4 5 6 7 8 9 10
		p++;
	}
	return 0;
}

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

• 1.二维数组的创建格式
  数据类型 + 数组名 [行] [列]，注意行和列是被抽象出来的
• 2.二维数组的初始化
• 3.二维数组的行可以省略，但是列不能省略(因为确定了列，就能代表一行有几个元素)

#include<stdio.h>
int main()
{
	//二维数组的创建
	int arr[3][4];//有12个整型类型的元素
	char ch[3][4];//有12个字符类型的元素

	
	//-----------------------------------------------------------
	//二维数组的初始化
	int arr1[3][4] = {1,2,3,4,5,6,7,   8,9,10,11,12};//完全初始化
	int arr2[3][4] = {1,2,3,4,5,6,7};//不完全初始化剩下的补0 
	
	//将二维数组里的第一行看作一维数组来初始化
	int arr3[3][4] = {{1,2}, {3,4}, {5,6}};
	//同int arr3[][4] = {{1,2}, {3,4}, {5,6}}; - 能省略行，但不能省略列	//调试
	//arr[0] -> {1,2,0,0}
	//arr[1] -> {3,4,0,0}
	//arr[2] -> {5,6,0,0}
	
	return 0;
}

五、二维数组的使用

• 打印二维数组中的元素，每一个元素都需要2个坐标来确定，所以需要2层循环
  

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

输出结果：

六、二维数组在内存中的存储

• 1.二维数组在内存中也是连续存放的(一行里的元素是连续的；行与行之间的元素也是连续的)。说明行与列是抽象出来的
• 2.二维数组里的每一行的数组名是arr[0]、arr[1]、arr[2]
  

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

输出结果：

• 3.二维数组在内存中是连续存放的，所以在拿到数组的起始位置时就能找到整个数组

#include<stdio.h>
int main()
{
	int arr[][4] = {{1,2}, {3,4}, {5,6}};
	int i = 0;
	int j = 0;
	int sz = sizeof(arr) / sizeof(arr[0][0]);//12
	int* p = &arr[0][0];
	for(i = 0; i < 12; i++)
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

输出结果：

七、数组名

• 在之前的学习中，我们知道数组名是数组首元素的地址，但是我们在sizeof(arr)是为什么不是4或者8呢？
  因为这有两个例外：
  sizeof(数组名) -> 此时计算的是整个数组的大小，单位是字节
     &数组名 -> 此时取出的是整个数组的地址

#include<stdio.h>
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	//数组名是首元素地址
	printf("%p\\n", &arr[0]);//00DDFD6C
	printf("%p\\n", arr);//00DDFD6C
	//--------------------------------------------
	//计算的是整个数组的大小
	printf("%d\\n", sizeof(arr));//40
	printf("%p\\n", &arr);//00DDFD6C
	return 0;
}

发现&arr[0]、arr、&arr是一样的：
数组名是首元素地址，所以arr和&arr[0]是一样的没有争议。
但是&arr不是整个数组的地址吗？
其实细想一下&arr拿到整个数组的地址和首元素的地址是相同的是能说的过去，但是意义不一样。
编写代码验证一下：

#include<stdio.h>
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	printf("%p\\n", &arr);//012FF828
	printf("%p\\n", &arr + 1);//012FF850
	
	printf("%p\\n", arr);012FF828
	printf("%p\\n", arr + 1);//012FF82C
	return 0;
}

可见&arr数组的地址+1跳过的是整个数组
arr首元素的地址+1跳过的是1个元素

八、数组作为函数参数

• 往往我们在写代码的时候，会将数组作为参数传给函数

1.冒泡排序

/***********************************************************************

• 目的：使用冒泡排序排列{1,3,5,7,9,2,4,6,8,10}为升序
• 分析：冒泡排序(两两相邻的元素进行比较，并且可能的话需要交换)。
• 平台：Visual studio 2017 && windows
  *************************************************************************/

#include<stdio.h>
void Bubble_Sort(int arr[], int sz)
{
	int i = 0;
	int j = 0;
	for(i = 0; i < sz - 1; i++)//外层
	{
		for(j = 0; j < sz - 1 - i; j++)//内层
		{
			if(arr[j] > arr[j + 1])//arr[j] < arr[j + 1]降序
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;	
			}
		}
	}
}
int main()
{
	//乱序
	int arr[] = {1,3,5,7,9,2,4,6,8,10};
	//升序
	int sz = sizeof(arr)/sizeof(arr[0]);
	Bubble_Sort(arr, sz);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

/***********************************************************************

• 目的：优化冒泡排序
• 分析：当我们发现{1,2,3,4,5,6,7,8,9,10}已经有序时，它还是要一个一个的比较，效率非常的低。事实上如果一趟冒泡排序里没有交换的情况下，就可以断定它是有序的
• 平台：Visual studio 2017 && windows
  *************************************************************************/

#include<stdio.h>
void Bubble_Sort(int arr[], int sz)
{
	int i = 0;
	int j = 0;
	for(i = 0; i < sz - 1; i++)
	{
		int flag = 1;
		for(j = 0; j < sz - 1 - i; j++)
		{
			if(arr[j] > arr[j + 1])
			{
				flag = 0;
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;	
			}
		}
		if(1 == flag)
			break;
	}
}
int main()
{
	int arr[] = {1,3,5,7,9,2,4,6,8,10};
	int sz = sizeof(arr)/sizeof(arr[0]);
	Bubble_Sort(arr, sz);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

九、字符数组

• 字符数组的初始化：

#include<stdio.h>
int main()
{
	char ch1[5] = {'b', 'i', 't'};//[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]
	
	//----------------------------------------------------
	//观察ch5、ch6分别的输出结果： - 字符中的结束标志是\\0
	char ch5[] = "bit";//[b i t \\0]
	char ch6[] = {'b', 'i', 't'};//[b i t] -  数组未指定大小，不会补\\0
	char ch7[5] = {'b', 'i', 't'};//[b i t \\0 \\0] - 数组指定大小
	
	printf("%s\\n", ch5);//bit
	printf("%s\\n", ch6);//bit烫烫烫烫蘠it(随机值)
	printf("%s\\n", ch7);//bit

	return 0;
}

十、数组的应用实例1：三子棋

十一、数组的应用实例2：扫雷游戏