第4节-数组

最新推荐文章于 2023-04-19 10:46:59 发布

随风张幔

最新推荐文章于 2023-04-19 10:46:59 发布

阅读量343

点赞数 2

分类专栏： c语言初阶文章标签： c语言 c#

本文链接：https://blog.csdn.net/qq_45113223/article/details/121159689

版权

c语言初阶专栏收录该内容

11 篇文章 0 订阅

订阅专栏

4.1.冒泡排序的例子（✳）

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

1.1.数组的创建

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

数组的创建方式：

type_t arr_name [ const_n ];

type_t 是指数组的元素类型

const_n 是一个常量表达式，用来指定数组的大小

int arr1[10];
char arr3[10];
float arr4[1];
double arr5[20];

int count = 10;
int arr2[count];   //VS编译器中不可以这么创建数组

注：数组创建，在C99标准之前， [ ] 中要给一个常量才可以，不能使用变量。在C99标准支持了变长数组的概念。（VS对C99标准的支持不够好）（在其他支持变长数组的编译器中创建变长数组的时候不能初始化）

1.2.数组的初始化

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

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

char arr4[3] = {'a',98, 'c'};          //7
char arr5[] = {'a','b','c'};           //8
char arr6[] = "abcdef";                //9

第一个是完全初始化

第二个叫不完全初始化，只初始化前三个元素，剩余的七个元素默认初始化为0

第三个是快速将所有十个元素都初始化为0

第四个如果不设定数组大小，那么它会根据初始化的内容，来确定他有几个元素

第五个数组初始化只有一个元素0

第六个数组若不初始化，那么里面的内容是随机值（不建议）

第七个数组没有问题，其中98就是b的ASCII值，这里面其实就是放了一个字符b的意思

第八个与第四、五个类似根据初始化的内容，来确定他有几个元素

第九个是使用字符串初始化字符数组，所以字符串是可以初始化字符数组的

char arr1[]={'a','b','c'};
char arr2[]="abc";

第一个数组有3个字符'a' 'b' 'c'，占3个字节；长度不确定；输出为abc+乱码

第二个数组有4个字符'a' 'b' 'c' '\0'，占4个字节；长度为3；输出为abc

注：

1.strlen是一个库函数，计算的是字符串的长度，并且只能针对字符串，关注的是字符串中是否有'\0'，计算的是'\0'之前的字符个数

2.sizeof是一个操作符（运算符），sizeof是用来计算变量所占内存空间大小，任何类型都可以使用只关注空间大小，不在乎内存中是否存在'\0'

1.3.一维数组的使用

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

注：

1.访问数组某一个元素的时候[ ]中可以是变量，指定数组大小的时候必须是常量。

2. 数组是使用下标来访问的，下标是从0开始。

3.数组的大小可以通过计算得到。

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

知识点一：

代码：

结论：

1.这里面每相隔两个元素之间地址都差4，因为一个整型元素的大小是4个字节，而一个字节用一个地址，所以每两个相邻元素之间地址相差4。

2.一维数组在内存是连续存放的。

3.数组随着下标的增长，地址是由低到高变化的

知识点二：

结论：只要p指向了这个数组第一个元素的地址（这里面第一个元素的地址是这四个字节中编号最小的地址），因为这里p是一个整型指针，给p+1就跳过4个地址（字节），指向第二个元素的地址（第二个元素四个地址中编号最小的地址），因此p+i就是arr[i]的地址。

知识点三：

结论：我们以后便可以不再用下标的形式访问数组了，使用*（p+i）就是下标为i的数组元素，其中解引用*就是访问一个整型空间（四个字节）的大小。

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

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};
int arr[3][4] = { {1,2},{3,4},{5,6} };
int arr[][]={1,2,3,4,5,6,7,8,9,10,11,12};   //错误
int arr[][4]={1,2,3,4,5,6,7,8,9,10,11,12};  //正确

第一个是完全初始化：第一行元素1 2 3 4 ，第二行元素5 6 7 8，第三行元素9 10 11 12

第二个是不完全初始化：第一行元素1 2 3 4 ，第二行元素5 6 7 0，第三行元素0 0 0 0

第三个是分别对每一行初始化：第一行元素1 2 0 0，第二行元素3 4 0 0，第三行元素5 6 0 0

第四个初始化方式是错误的，因为这12个元素可以认为是3行4列，2行6列等等，并不唯一

第五个是正确的，因为把列数指定了就知道一行有几个元素了，结果是唯一的。

注：二维数组的行可以省略，列不能省略。（有行数没有列数是不行的）

2.3 二维数组的使用

二维数组的使用也是通过下标的方式

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

知识点一：

形象表述为：

理论上，我们认为二维数组是下图

实际上，在内存中是如下图存储的

结论：

1.在我们的感觉中二维数组是多行多列的，然而实际中在内存里地址是连续的

2.我们把第一行的一维数组叫做arr[0]，第二行的一维数组叫做arr[1]，第三行的一维数组叫做arr[2]，所以二维数组可以理解为一维数组的数组

3. 数组越界

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

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

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

C 语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，所以程序员写代码时，最好自己做越界的检查。

数组越界对一维数组、二维数组都可能会越界

注:上图就是数组越界的例子。arr数组只有10个元素，下标是0-9，而for循环给第10个下标赋值，第10个下标不是数组的内容，因此数组越界了。如下图：

......		0	1	2	3	4	5	6	7	8	9	............
其他内存空间		arr数组内存空间										其他内存空间

越界错误的提示：（c语言语法对数组越界是没有能力去检查的，编译器会去检查一下，但能力也是有限的，有时候识别不出来如下面第二个）

1.箭头处arr是你越界的数组名：

2.系统没有报错，但是输出结果是错的。

4. 数组作为函数参数

4.1.冒泡排序的例子（✳）

描述：

设计一个函数对arr数组进行排序

冒泡排序思路：（n个元素需要n-1次冒泡排序；第一次排序n个元素需要n-1次比较，第二次排序最后一个固定，n-1个元素需要n-2次比较，依此类推）

代码：

注：

1.数组在传参时，实参只能使用数组名

2.数组在传参时，形参可以是 int(char等) arr[ ]（数组名）或 int*（char*等） arr（指针变量名），两者完全一样。

3.这里我们可以看出 arr[i]和 p[i]（此处p是数组首元素的地址）是相同的，如下图，所有数组中都用的是p[i]的形式。（其实arr本身也就是首元素的地址，两者本质完全一样）

4.实际上数组传参传递的不是整个数组，传过去的是数组首元素的地址。

5. 数组传参的时候传的是首元素的地址，写arr[0]其实是通过这个地址找到第一个元素的地址。也就是说在主函数中，函数名既可表示该数组，也是首元素地址的意思。而在函数调用数组时，不管形参是以指针形式接收还是以arr[ ]数组这种形式接收（这两种形式意思和功能完全一样），接收的都只是数组首元素的地址，只不过在函数中可以通过数组首元素地址找到arr[1]等元素的地址，因此在函数中也可以使用arr[1]等。

6.数组名相当于是地址，因此传的时候是地址，相当于传址调用。

4.2.数组名是什么

结论：数组名是数组首元素的地址（有两个例外）

例外：

1. sizeof内部单独放一个数组名，数组名表示整个数组，sizeof（数组名）计算的是整个数组的大小，单位是字节。（在函数中不成立）

2. &数组名，数组名表示整个数组，取出的是整个数组的地址

注：数组的地址打印出来其实也是数组首元素的地址，但是是有区别的，如下，给一个数组的地址加1，是加上整个数组的大小，这里面加了个20，因为是5个整型元素。

5.程序实例（三子棋和扫雷游戏）（✳）

5.1.三子棋

文件分配：

test.c 代码：

#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"

void menu()
{
	printf("************************\n");
	printf("*****   1. play   ******\n");
	printf("*****   0. exit   ******\n");
	printf("************************\n");
}

void game()
{
	//数据存储到一个字符的二维数组中，玩家下棋是'*',电脑下棋是'#',
	char board[ROW][COL] = { 0 };//数组的内容应该是全部空格
	InitBoard(board, ROW, COL);//初始化棋牌
	//打印棋盘
	DisplayBoard(board, ROW, COL);
	//下棋
	char ret = 0;
	while (1)
	{
		player_move(board, ROW, COL);
		DisplayBoard(board, ROW, COL);
		ret = is_win(board, ROW, COL);
		if (ret != 'C')
		{
			break;
		}
		computer_move(board, ROW, COL);
		DisplayBoard(board, ROW, COL);
		ret = is_win(board, ROW, COL);
		if (ret != 'C')
		{
			break;
		}
	}
	if (ret == '*')
	{
		printf("玩家赢\n");
	}
	else if (ret == '#')
	{
		printf("电脑赢\n");
	}
	else
	{
		printf("平局\n");
	}
}


void test()
{
	int input = 0;
	srand((unsigned int)time(NULL));
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}

	} while (input);
}

int main()
{
	test();

	return 0;
}

game.c 代码：

#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"

void InitBoard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			board[i][j] = ' ';
		}
	}
}

//版本1
//void DisplayBoard(char board[ROW][COL], int row, int col)
//{
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < row; i++)
//	{
//		//数据
//		printf(" %c | %c | %c \n", board[i][0], board[i][1], board[i][2]);
//		//分割行
//		if(i<row-1)
//			printf("---|---|---\n");
//	}
//}


//版本2
void DisplayBoard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		//数据
		for (j = 0; j < col; j++)
		{
			printf(" %c ", board[i][j]);
			if (j < col - 1)
				printf("|");
		}
		printf("\n");
		//分割行
		if (i < row - 1)
		{
			for (j = 0; j < col; j++)
			{
				printf("---");
				if (j < col - 1)
					printf("|");
			}
		}
		printf("\n");
	}
}


//玩家下棋
void player_move(char board[ROW][COL], int row, int col)
{
	printf("玩家下棋:>");
	int x = 0;
	int y = 0;

	while (1)
	{
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (board[x - 1][y - 1] == ' ')
			{
				board[x - 1][y - 1] = '*';
				break;
			}
			else
			{
				printf("该坐标被占用，请重新输入！\n");
			}
		}
		else
		{
			printf("坐标非法，请重输入!\n");
		}
	}
}



void computer_move(char board[ROW][COL], int row, int col)
{
	int x = 0;
	int y = 0;
	printf("电脑下棋>\n");
	while (1)
	{
		x = rand() % ROW;//0~2
		y = rand() % COL;//0~2
		if (board[x][y] == ' ')
		{
			board[x][y] = '#';
			break;
		}
	}
}

int is_full(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
			{
				return 0;
			}
		}
	}
	return 1;
}

char is_win(char board[ROW][COL], int row, int col)
{
	int i = 0;
	//三行
	for (i = 0; i < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
		{
			return board[i][1];
		}
	}
	//三列
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[1][i] != ' ')
		{
			return board[1][i];
		}
	}
	//对角线的判断
	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
	{
		return board[1][1];
	}

	if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
	{
		return board[1][1];
	}

	//判断平局
	if (1 == is_full(board, row, col))
	{
		return 'Q';
	}
	//继续
	return 'C';
}

game.h 代码：

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

#define ROW 3
#define COL 3


//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col);

//打印棋盘
void DisplayBoard(char board[ROW][COL], int row, int col);

//玩家下棋
void player_move(char board[ROW][COL], int row, int col);

//电脑下棋
void computer_move(char board[ROW][COL], int row, int col);

//判断输赢的代码
//玩家赢 - '*'
//电脑赢 - '#'
//平均 --- 'Q'
//继续 ----'C'

char is_win(char board[ROW][COL], int row, int col);

运行结果：

5.2.扫雷游戏

文件分配：

test.c 代码：

#define _CRT_SECURE_NO_WARNINGS 1


#include "game.h"

void menu()
{
	printf("***********************\n");
	printf("*****  1. play     ****\n");
	printf("*****  0. exit     ****\n");
	printf("***********************\n");
}


void game()
{
	//创建数组
	char mine[ROWS][COLS] = { 0 };//存放布置好的雷的信息
	char show[ROWS][COLS] = { 0 };//存放排查出的雷的信息

	//初始化mine数组为全'0'
	InitBoard(mine, ROWS, COLS, '0');
	//初始化show数组为全'*'
	InitBoard(show, ROWS, COLS, '*');

	//打印棋盘
	//DisplayBoard(mine, ROW, COL);

	//布置雷
	SetMine(mine, ROW, COL);
	DisplayBoard(show, ROW, COL);

	//DisplayBoard(mine, ROW, COL);
	//排雷
	FindMine(mine, show, ROW, COL);
}

void test()
{
	int input = 0;
	srand((unsigned int)time(NULL));

	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			//扫雷
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
}

int main()
{
	test();
	return 0;
}

game.c代码：

#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"


void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}


void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	//1~9
	int i = 0;
	int j = 0;

	//列号的打印
	for (i = 0; i <= col; i++)
	{
		printf("%d ", i);
	}
	printf("\n");

	for (i = 1; i <= row; i++)
	{
		printf("%d ", i);//打印行号

		for (j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
}

void SetMine(char mine[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;

	while (count)
	{
		int x = rand() % row + 1;
		int y = rand() % col + 1;

		if (mine[x][y] == '0')
		{
			mine[x][y] = '1';
			count--;
		}
	}
}

static int get_mine_count(char mine[ROWS][COLS], int x, int y)
{
	return mine[x - 1][y] +
		mine[x - 1][y - 1] +
		mine[x][y - 1] +
		mine[x + 1][y - 1] +
		mine[x + 1][y] +
		mine[x + 1][y + 1] +
		mine[x][y + 1] +
		mine[x - 1][y + 1] - 8 * '0';
}


void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	int win = 0;

	while (win < row * col - EASY_COUNT)
	{
		printf("请输入要排查的坐标:>");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (mine[x][y] == '1')
			{
				printf("很遗憾你被炸死了\n");
				DisplayBoard(mine, row, col);
				break;
			}
			else
			{
				//计算x,y坐标周围有几个雷
				int n = get_mine_count(mine, x, y);
				show[x][y] = n + '0';
				DisplayBoard(show, row, col);
				win++;
			}
		}
		else
		{
			printf("输入坐标非法，无法排雷，请重新输入\n");
		}
	}
	if (win == row * col - EASY_COUNT)
	{
		printf("恭喜你，排雷成功\n");
		DisplayBoard(mine, row, col);
	}

}

game.h代码：

#pragma once

//头文件的包含
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

//符号的声明
#define ROW 9
#define COL 9

#define ROWS ROW+2
#define COLS COL+2

#define EASY_COUNT 10

//函数的声明

//初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);

//打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col);

//布置雷
void SetMine(char mine[ROWS][COLS], int row, int col);

//排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

运行结果：