【C语言】实现递归式扫雷

我不是女神ヾ 2022-10-21 14:54 165阅读 0赞

# 实现递归式扫雷 #

### c语言实现扫雷进阶 ###

*  实现递归式扫雷
 *  前言
 *  效果图
 *  模仿目标
 *  一、扫雷基本步骤
 *  二、基础框架
 *   *  2.获得周边雷数
     *   *  3.对周边进行递归展开（重点）
         *   *  4.附上全部代码
 *  总结

--------------------

# 前言 #

前期介绍了扫雷基础版，但那种模式下只能单一单一的打开，缺少趣味性，本次模拟更接近实际，添加了标记的代码实现，和递归展开的代码实现

# 效果图 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjM0NDQwMQ_size_16_color_FFFFFF_t_70]

# 模仿目标 #

![在这里插入图片描述][20210503004221670.png]  
圈起来的部分我们用‘？’这个字符进行表示

# 一、扫雷基本步骤 #

上期内容：  
1.创建棋盘，初始化棋盘  
2.打印棋盘  
3.设置随机雷  
4.进行单个打开玩耍  
本期对这些不再进行说明，详情上期，下面附上链接  
！！！！！[扫雷基础篇][Link 1]

本期主要讲述：**递归**对数组进行展开，对还没展开的雷进行标记

# 二、基础框架 #

创建两个二维数组，一个给自己放雷使用，一个给玩家使用  
原因：调试的时候可以用mine数组看哪是否有雷，对程序进行检查。使得整体不会混乱，如果只有一个给玩家使用的，埋雷时放’1’,和展开时标记’1’会混乱，分不清谁

char show[ROWS][COLS] = {  0 };
    	char mine[ROWS][COLS] = {  0 };
    	InitBoard(show, ROWS, COLS, '*');
    	InitBoard(mine, ROWS, COLS, '0');

void InitBoard(char mine[ROWS][COLS], int rows, int cols, char ret)
    { 
    	for (int i = 0; i < rows; i++)
    	{ 
    		for (int j = 0; j < cols; j++)
    		{ 
    			mine[i][j] = ret;
    		}
    	}
    }
    void DisplayBoard(char show[ROW][COL], int row, int col)
    { 
    	printf("-------------扫雷游戏-----------\n");
    	//打印第一行的0 1 2 3 .。。
    	for (int i = 0; i <= row; i++)
    	{ 
    		printf("%d ", i);
    	}
    	printf("\n");
    	for (int i = 1; i <= row; i++)
    	{ 
    		printf("%d ", i);
    		for (int j = 1; j <= col; j++)
    		{ 
    			printf("%c ", show[i][j]);
    		}
    		printf("\n");
    	}
    	printf("-------------扫雷游戏-----------\n");
    }
    void SetMine(char show[ROW][COL], int row, int col)
    { 
    	int count = EASY_COUNT;//我们要设置十个雷
    	while (count)
    	{ 
    		int x = rand()%row+1; int y = rand() % col + 1;
    		if (show[x][y] == '0')
    		{ 
    			show[x][y] = '1';
    			count--;
    		}
    	}
    }

## 2.获得周边雷数 ##

static int GetAround(char mine[ROW][COL], int x, int y)//只在当前源文件使用
    { 
    	return mine[x - 1][y - 1] +
    		mine[x - 1][y] +
    		mine[x - 1][y + 1] +
    		mine[x][y - 1] +
    		mine[x][y + 1] +
    		mine[x + 1][y - 1] +
    		mine[x + 1][y] +
    		mine[x + 1][y + 1] - 8 * '0';
    }

### 3.对周边进行递归展开（重点） ###

递归当前坐标的上下左右，将递归过的放入’ ',递归时就不会发生重复递归！！

void _PlayBoard(char mine[ROW][COL], char show[ROW][COL], int row, int col, int x, int y, int* count)
    { 
    	if (x > row || x < 1 || y>col || y < 1)
    		return;
    	char ret = GetAround(mine, x, y) + '0';
    	if (ret == '0')
    	{ 
    		show[x][y] = ' ';//这里是因为如果还存‘0’，就会重复递归这个位置，所以下面的判断条件show数组得是放着‘*’。
    		(*count)++;//只要打开附近有无雷，count都要++
    	}
    	else
    	{ 
    		show[x][y] = ret;
    		(*count)++;
    		return;//当不满足周围没有雷就把数字填上去，返回到上一层
    	}//每个雷判断上下左右就可以了，就可以递归自己的上下左右
    	if (show[x - 1][y] == '*' && x - 1 >= 1)
    	{ 
    		_PlayBoard(mine, show, row, col, x-1, y, count);
    	}
    	if (show[x + 1][y] == '*' && x +1 <= row )
    	{ 
    		_PlayBoard(mine, show, row, col, x+1, y, count);
    	}
    	if (show[x ][y-1] == '*' && y-1>=1 )
    	{ 
    		_PlayBoard(mine, show, row, col, x, y-1, count);
    	}
    	if (show[x ][y+1] == '*' && y+1<=col )
    	{ 
    		_PlayBoard(mine, show, row, col, x, y+1, count);
    	}
    }

#### 4.附上全部代码 ####

------------game.h----------------------
    #pragma once
    #include<stdio.h>
    #include<stdlib.h>
    #include<time.h>
    #define ROW 9
    #define COL 9
    #define ROWS ROW+2
    #define COLS COL+2
    #define EASY_COUNT 10
    void InitBoard(char mine[ROWS][COLS], int rows, int cols, char ret);
    void DisplayBoard(char show[ROW][COL], int row, int col);
    void SetMine(char show[ROW][COL], int row, int col);
    void PlayBoard(char mine[ROW][COL], char show[ROW][COL], int row, int col);
    --------------------------game.c----------------------------
    #define _CRT_SECURE_NO_WARNINGS 1
    #include"game.h"
    void InitBoard(char mine[ROWS][COLS], int rows, int cols, char ret)
    { 
    	for (int i = 0; i < rows; i++)
    	{ 
    		for (int j = 0; j < cols; j++)
    		{ 
    			mine[i][j] = ret;
    		}
    	}
    }
    void DisplayBoard(char show[ROW][COL], int row, int col)
    { 
    	printf("-------------扫雷游戏-----------\n");
    	//打印第一行的0 1 2 3 .。。
    	for (int i = 0; i <= row; i++)
    	{ 
    		printf("%d ", i);
    	}
    	printf("\n");
    	for (int i = 1; i <= row; i++)
    	{ 
    		printf("%d ", i);
    		for (int j = 1; j <= col; j++)
    		{ 
    			printf("%c ", show[i][j]);
    		}
    		printf("\n");
    	}
    	printf("-------------扫雷游戏-----------\n");
    }
    void SetMine(char show[ROW][COL], int row, int col)
    { 
    	int count = EASY_COUNT;//我们要设置十个雷
    	while (count)
    	{ 
    		int x = rand()%row+1; int y = rand() % col + 1;
    		if (show[x][y] == '0')
    		{ 
    			show[x][y] = '1';
    			count--;
    		}
    	}
    }
    static int GetAround(char mine[ROW][COL], int x, int y)//只在当前源文件使用
    { 
    	return mine[x - 1][y - 1] +
    		mine[x - 1][y] +
    		mine[x - 1][y + 1] +
    		mine[x][y - 1] +
    		mine[x][y + 1] +
    		mine[x + 1][y - 1] +
    		mine[x + 1][y] +
    		mine[x + 1][y + 1] - 8 * '0';
    }
    void _PlayBoard(char mine[ROW][COL], char show[ROW][COL], int row, int col, int x, int y, int* count)
    { 
    	if (x > row || x < 1 || y>col || y < 1)
    		return;
    	char ret = GetAround(mine, x, y) + '0';
    	if (ret == '0')
    	{ 
    		show[x][y] = ' ';//这里是因为如果还存‘0’，就会重复递归这个位置，所以下面的判断条件show数组得是放着‘*’。
    		(*count)++;//只要打开附近有无雷，count都要++
    	}
    	else
    	{ 
    		show[x][y] = ret;
    		(*count)++;
    		return;//当不满足周围没有雷就把数字填上去，返回到上一层
    	}//每个雷判断上下左右就可以了，就可以递归自己的上下左右
    	if (show[x - 1][y] == '*' && x - 1 >= 1)
    	{ 
    		_PlayBoard(mine, show, row, col, x-1, y, count);
    	}
    	if (show[x + 1][y] == '*' && x +1 <= row )
    	{ 
    		_PlayBoard(mine, show, row, col, x+1, y, count);
    	}
    	if (show[x ][y-1] == '*' && y-1>=1 )
    	{ 
    		_PlayBoard(mine, show, row, col, x, y-1, count);
    	}
    	if (show[x ][y+1] == '*' && y+1<=col )
    	{ 
    		_PlayBoard(mine, show, row, col, x, y+1, count);
    	}
    }
    void PlayBoard(char mine[ROW][COL], char show[ROW][COL], int row, int col)
    { 
    	int x = 0; int y = 0;
    	int count = 0;
    	//判断坐标合法性
    	while ((row * col - count)!=EASY_COUNT)
    	{ 
    		int i = 0;
    		printf("****输入0进入标记*****\n");
    		printf("****输入1进入落子*****\n");
    		scanf("%d", &i);
    		while (i == 0)
    		{ 
    			printf("请输入你要标记点的坐标！\n");
    			scanf("%d %d", &x, &y);
    			if (x >= 1 && x <= row && y >= 1 && y <= col&&show[x][y]=='*')
    			{ 
    				show[x][y] = '?';
    				i = 1;
    				DisplayBoard(show, row, col);
    			}
    			else
    			{ 
    				printf("输入坐标不合法\n");
    			}
    		}
    		if (i == 1)
    		{ 
    		printf("请输入你要下的坐标\n");
    		scanf("%d %d", &x, &y);
    		if (x >= 1 && x <= row && y >= 1 && y <= col)
    		{ 
    			if (show[x][y] == '*'||show[x][y]=='?')
    			{ 
    				if (mine[x][y] == '1')
    				{ 
    					break;
    				}
    				if (mine[x][y] == '0')
    				{ 
    					_PlayBoard(mine, show, row, col, x, y, &count);//递归子函数，帮我们打印周边的数
    					DisplayBoard(show, ROW, COL);
    				}
    				else
    				{ 
    					show[x][y] = ' ';
    					DisplayBoard(show, ROW, COL);
    					count++;
    				}
    
    			}
    			else//不为*表示这个位置都是已经展开过的
    			{ 
    				printf("已经下过,请重新落子\n");
    			}//这里表示坐标合法，但这个位置已经下过
    		}
    		else 
    		{ 
    			printf("输入坐标错误，请重新输入\n");
    		}
    		}
    		
    	}
    	if ((row * col - count) == EASY_COUNT)
    		printf("闯关成功，恭喜你\n");//两种情况，一种为while条件不满足跳出来
    	else
    		printf("你已经被炸死\n");//一种为已经猜到炸弹了
    	DisplayBoard(mine, ROW, COL);
    }
    --------------------------test.c---------------------
    #define _CRT_SECURE_NO_WARNINGS 1
    #include"game.h"
    void meau()
    { 
    	printf("************************\n");
    	printf("****** 1.play *****\n");
    	printf("****** 0.exit *****\n");
    	printf("************************\n");
    }
    void game()
    { 
    	//先创建棋盘，一个给自己布置雷看，一个给玩家看
    	char show[ROWS][COLS] = {  0 };
    	char mine[ROWS][COLS] = {  0 };
    	InitBoard(show, ROWS, COLS, '*');
    	InitBoard(mine, ROWS, COLS, '0');
    	DisplayBoard(show, ROW, COL);
    	SetMine(mine, ROW, COL);
    	//DisplayBoard(mine, ROW, COL);
    	PlayBoard(mine, show, ROW, COL);
    
    }
    int main()
    { 
    	srand((unsigned int)time(NULL));
    	int input = 0;
    	
    	do
    	{ 
    		meau();
    		printf("请输入数字0或1\n");
    		scanf("%d", &input);
    		switch (input)
    		{ 
    		case 1:
    			game();
    			break;
    		case 0:
    			printf("退出游戏\n");
    			break;
    		default:
    			printf("请重新输入\n");
    			break;
    		}
    	} while (input);
    }

# 总结 #

凡是涉及到递归的知识，只要弄不懂，一定要多画图，在之后的二叉树学习等递归的知识需要大量使用，凡是没弄到的朋友可以学习汉诺塔和青蛙跳台阶等的问题，看别人做十遍不如自己画图搞懂一遍！  
\-\_-本次分享就到这里，如果觉得还不错的可以一键三连哦，这对我很重要！！！！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjM0NDQwMQ_size_16_color_FFFFFF_t_70]: /images/20221021/62b7ee979af649aba127345c33d827e5.png
[20210503004221670.png]: /images/20221021/ab5286a29c2e4d49a4fe441a6fbf3d92.png
[Link 1]: https://blog.csdn.net/weixin_52344401/article/details/113817737?spm=1001.2014.3001.5501