N子棋的实现(以三子棋为例)——保姆级流程

已于 2022-08-03 09:36:57 修改
阅读量1.3k 收藏 7
点赞数
分类专栏： C语言 文章标签： 数据结构 c语言
于 2022-08-03 09:31:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zijin555/article/details/126065284
版权

目录

大致思路：

棋子是什么？

怎么创建棋盘？ 

初始化二维数组：

打印棋盘：

玩家下棋：

电脑下棋：

棋子随机性：

判断胜负：

1.一整行为同一元素：

2.一整列为同一元素：

3.正对角线为同一元素：

4.反对角线为同一元素：

 5.判单平局  或  游戏继续：

翻译返回字符：​​​​​​​

 下面是上诉所有函数结合起来的game函数的结构：

最终代码：

头文件：game.h

源文件：game.c

源文件：test.c

总结：

这期内容是用C语言来实现三子棋的操作：

大致思路：

  1. 打印棋盘：创建二维数组，用二维数组的元素来表示玩家与电脑下的棋子
  2. 玩家下棋：用 * 来表示玩家下的棋子
  3. 电脑下棋：用 # 来表示电脑下的棋子
  4. 判断胜负：一整行或一整列为同一棋子，则该棋子所代表的玩家获胜；正对角线或反对角线为同一棋子，则该棋子所代表的玩家获胜
  5. 若没有分出胜负，即为平局

棋子是什么？

像三子棋这样的平面结构，我们最先想到的就是同样具有平面结构的二维数组，

对于三子棋来说，创建一个3x3的二维数组是最好不过的，

我们可以用二维数组的元素来充当棋子，

比如：创建char类型的二维数组

为了方便实现N子棋，我们定义宏来控制棋盘的大小。

想玩“N”子棋，就将两个常量改为“N”。

#define ROW 3
#define COL 3

char board[3][3] = { 0 };

用 '*' 来表示玩家下的棋子，用 '#' 来表示电脑下的棋子。

先说到这里，大致了解一下思路，后面会详细地讲解。

怎么创建棋盘？ 

 如图所示：

看似简单实则内涵非常多的细节：

每一个格都有三个空格来组成，其目的就是为了让棋盘美观一点，不要显得这么拥挤。

二维数组的元素当然也要插入其中，好让我们后期做修改：

初始化二维数组：

将二维数组全部初始化为 ' ' （空格）

//初始化的函数
void init_board(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] = ' ';
		}
	}
}

因此，我们可以用下面的形式来打印出来：

printf(" %c | %c | %c ", board[0][0], board[0][1], board[0][2]);

第二部分就是水平分界线，可以直接打印出来：

printf("---|---|---");

这样一来，就大致了解如何实现真正的棋盘打印了！！！

打印棋盘：

总体看来，无论是空格部分，还是水平的分界线部分，都包含两种元素，

1.空格部分：包括：' %c ' 与 | ，但是 | 比 %c 少一个，所以我们来分开打印：

//打印棋盘的函数
void display_board(char board[ROW][COL], int row, int col)
{
	int i = 0;

	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			printf(" %c ", board[i][j]); //先打印' %c '
			if (j < col - 1)             //保证最后一次不会多打印一个'|'
				printf("|");
		}
		printf("\n");                    //换行，打印水平分割线
		if (i < row - 1)
		{
			int j = 0;
			for (j = 0; j < col; j++)
			{
				printf("---");           //先打印'---'
				if (j < col - 1)         //同理，确保最会一次不会多打印一个'|'  
					printf("|"); 
			}
			printf("\n");

		}
	}
}

玩家下棋：

我们可以通过坐标来决定玩家所下棋的位置，

创建变量，n 表示行，m 表示列

但是二维数组的下标均从 0 开始，

所以我们可以在代码上动手脚，输入的坐标(n,m)其实就是二维数组的行、列，

当我们读取时就直接 -1 即可：

board[n-1][m-1] 

玩家下的棋子为 ' * ' 

所以只需将二维数组该位置的 ' ' (空格)改为 ' * ' 即可

ps: 需要注意的是“下棋”前要先判断输入的坐标所在位置位置是否为 空格，

不是空格的话就说明该位置已被占用，是空格就可以直接将空格改为 * 

//玩家下棋的函数  //*
void player_move(char board[ROW][COL], int row, int col)
{
	printf("请玩家下棋\n请输入下棋的坐标:>");
	int n, m;
	while (1)
	{
		scanf("%d%d", &n, &m);
		if (board[n - 1][m - 1] != ' ')
		{
			printf("该坐标已被占用，请重新输入:>");   //被占用就while循环
		}
		else
			break;     //直到输入的坐标没有被占用，break跳出循环
	}
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			if (i == n - 1 && j == m - 1)
			{
				board[i][j] = '*'; //双重for循环，找到所输入坐标对应的二维数组的元素，改为*
			}
		}
	}
}

电脑下棋：

电脑下棋也是要通过更改二维数组中的元素来实现。

电脑下的棋子为 ' # ' 

电脑下棋最大的问题就是要保证电脑下棋的随机性：

棋子随机性：

我们依然要创建 n,m 来保存电脑下棋的坐标

通过 rand - srand 库函数 来确保电脑下棋的随机性：

srand要在主函数起始位置定义，同时通过time库函数，运用时间戳来确保随机性，

因为时间是 无时无刻都在变化的。

rand() 的取值范围为 0 ~ 32767 ，

因此，通过取模可以获得固定的取值范围

int n = rand() % ROW;   // ROW 的值为3， n 的取值范围就为 0~2

int m = rand() % COL;   // COL   的值为3，m 的取值范围就为 0~2

电脑下棋的坐标 (n,m) 的取值范围均为0~2，正好符合二维数组的范围。

ps：同样的，电脑下棋也要先判断坐标是否被占用，与玩家下棋的逻辑相同

void computer_move(char board[ROW][COL], int row, int col)
{
	int n = 0;
	int m = 0;
	while (1)
	{
		n = rand() % ROW;
		m = rand() % COL;
		if (board[n][m] != ' ')
			;
		else
			break;
	}
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			if (i == n && j == m)
			{
				board[i][j] = '#';
			}
		}
	}
}

ps：玩家与电脑下棋的过程要循环进行，直到分出结果才能停止。

判断胜负：

结果包含四种情况，每次玩家或者电脑下完一步之后就判断一次：

创建一个char 类型的函数，

若玩家获胜 ，则返回 '*' ;

若电脑获胜 ，则返回 '#' ;

若平局，则返回 'q' ;

若没分出胜负，且棋盘上还有空位，则返回 'c'  , 表示游戏继续；

判断胜负可以分为5个方面：

1.一整行为同一元素：

思路：一行一行地判断，通过计算 ' * ' 或 ' # ' 元素的个数来判断是否一整行均为同一元素。

	//判断行
	for (i = 0; i < row; i++)       //行数
	{
		int conut1 = 0;             //计算' * ' 的个数
		int conut2 = 0;             //计算' # ' 的个数
		for (j = 0; j < col; j++)   //一行的判断
		{
			if (board[i][j] == '*')
			{
				conut1++;      //为' * ' 就++一下
			}
			else if (board[i][j] == '#')
			{
				conut2++;     //为' # ' 就++一下
			}
		}
		if (conut1 == col)    //判断是否满足一整行元素个数，
                              //若满足则说明这一行均为该元素，从而判断胜负
		{
			return '*';
		}
		if (conut2 == col)
		{
			return '#';
		}
	}

2.一整列为同一元素：

判断列与判断行类似，就不在这里赘述了

	//判断列
	for (j = 0; j < col; j++)
	{
		int conut1 = 0;
		int conut2 = 0;
		for (i = 0; i < row; i++)
		{
			if (board[i][j] == '*')
			{
				conut1++;
			}
			else if (board[i][j] == '#')
			{
				conut2++;
			}
		}
		if (conut1 == row)
		{
			return '*';
		}
		if (conut2 == row)
		{
			return '#';
		}
	}

3.正对角线为同一元素：

思路：棋盘的行与列是相同的，所以正对角线上元素的行与列的下标也是相同的，只需判断对角线的元素是否均为同一元素。

	//判断正对角线
	int conut1 = 0;               //同样通过两个变量来分别判断两类元素的个数
	int conut2 = 0;
	for (i = 0; i < row; i++)
	{
		if (board[i][i] == '*')   //为 '*' 
		{
			conut1++;            //conut1++一下
		}
		else if (board[i][i] == '#')  //为 '#'
		{
			conut2++;           //conut2++一下
		}
	}
	if (conut1 == row)          //判断两个变量是否满足对角线元素的个数，
	{                           //若满足，则该元素所对的对象获胜
		return '*';
	}
	if (conut2 == row)
	{
		return '#';
	}

4.反对角线为同一元素：

反对角线较正对角线稍微复杂一点，需要准确找出反对角线上的各个元素的下标，

我们可以通过行数(或列数)的大小来获取反对角线上的元素，

比如3x3的棋盘，对角线的元素即为 ：

board[0][3-1] 、board[1][3-1-1] 、board[2][3-1-2]

	//判断反对角线
	conut1 = 0;
	conut2 = 0;
	for (i = 0; i < row; i++)             //i 来表示行， row-1 来表示列
	{
		if (board[i][row - 1 - i] == '*')  //同理，判断个数
		{
			conut1++;
		}
		else if (board[i][row - 1 - i] == '#')
		{
			conut2++;
		}
	}
	if (conut1 == row)                  //同理，判断个数是否匹配
	{
		return '*';
	}
	if (conut2 == row)
	{
		return '#';
	}

 5.判单平局  或  游戏继续：

思路：若上面的条件均不满足，那就来看一下棋盘中是否还有空格，

          若有空格，那就说明游戏还没有结束，游戏继续；

          若没有空格，就说明游戏结束了，结局为平局。

 没有空格，平局！

	//判断平局
	int conut3 = 0;
	for (i = 0; i < row; i++)      //用双层for循环来一个一个元素判断是否为空格
	{
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')   //为空格，conut3++一下
			{
				conut3++;
			}
		}
	}
	if (conut3 == 0)      // 若conut3等于0，就说明棋盘中没有空格了，平局！
	{
		return 'q';
	}
    return 'c';

 以上情况我们直接拼接起来，只要满足其中一种，直接return跳出来就好了。

最后，这是该判断胜负函数的整体样貌：

//判断胜负的函数
char is_win(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	//判断行
	for (i = 0; i < row; i++)
	{
		int conut1 = 0;
		int conut2 = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == '*')
			{
				conut1++;
			}
			else if (board[i][j] == '#')
			{
				conut2++;
			}
		}
		if (conut1 == col)
		{
			return '*';
		}
		if (conut2 == col)
		{
			return '#';
		}
	}
	//判断列
	for (j = 0; j < col; j++)
	{
		int conut1 = 0;
		int conut2 = 0;
		for (i = 0; i < row; i++)
		{
			if (board[i][j] == '*')
			{
				conut1++;
			}
			else if (board[i][j] == '#')
			{
				conut2++;
			}
		}
		if (conut1 == row)
		{
			return '*';
		}
		if (conut2 == row)
		{
			return '#';
		}
	}
	//判断正对角线
	int conut1 = 0;
	int conut2 = 0;
	for (i = 0; i < row; i++)
	{
		if (board[i][i] == '*')
		{
			conut1++;
		}
		else if (board[i][i] == '#')
		{
			conut2++;
		}
	}
	if (conut1 == row)
	{
		return '*';
	}
	if (conut2 == row)
	{
		return '#';
	}
	//判断反对角线
	conut1 = 0;
	conut2 = 0;
	for (i = 0; i < row; i++)
	{
		if (board[i][row - 1 - i] == '*')
		{
			conut1++;
		}
		else if (board[i][row - 1 - i] == '#')
		{
			conut2++;
		}
	}
	if (conut1 == row)
	{
		return '*';
	}
	if (conut2 == row)
	{
		return '#';
	}
	//判断平局
	int conut3 = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
			{
				conut3++;
			}
		}
	}
	if (conut3 == 0)
	{
		return 'q';
	}
	return 'c';
}

翻译返回字符：

创建一个字符变量 is 用来接收判断胜负返回的字符，传参到翻译字符的函数：

与判断胜负函数的返回值相呼应：

接受到 '*' ，则玩家获胜；

接受到 '*' ，则电脑获胜；

接收到'q'或者'*'、'#'都没有接收到，则平局；

这时就有小伙伴问了，不是还有一个'c'代表游戏继续的吗？

因为游戏继续不是最终结果，只有当出现获胜者或者平局的情况才是最终结果；

所以，在游戏没有结束的时候，字符变量 is 总会被赋值为 'c' ，我们只需在每次下棋之后判断一下is 是否为 'c' 就可以了，用不着让翻译字符函数来判断；

若 is 为 'c' ，则游戏继续；

若 is 不为 'c' ，则break跳出循环，进入到翻译字符函数，输出结果。

//翻译字符
void read_char(char is)
{
	if (is == '*')
	{
		printf("玩家赢了\n");
	}
	else if (is == '#')
	{
		printf("电脑赢了\n");
	}
	else
	{
		printf("平局\n");
	}
}

 下面是上诉所有函数结合起来的game函数的结构：

void game()
{
	char board[ROW][COL] = { 0 };
	//初始化棋盘
	init_board(board, ROW, COL);
	//打印棋盘
	display_board(board, ROW, COL);
	char is = '0';
	while (1)
	{
		//玩家下棋  //*
		player_move(board, ROW, COL);
		//判断胜负
		is = is_win(board, ROW, COL);          //对is进行赋值
		if (is != 'c')                         //判断是否游戏继续
		{
			break;
		}
		//电脑下棋  //#
		computer_move(board, ROW, COL);
		//判断胜负
		is = is_win(board, ROW, COL);          //对is进行赋值
		if (is != 'c')                         //判断是否游戏继续
		{
			break;
		}
		//打印
		display_board(board, ROW, COL);
	}
	//清除界面
	system("cls");                     //这里是清除界面的语句，使界面看起来整洁一些
	//翻译字符
	read_char(is);                     //判断结果
	//打印
	display_board(board, ROW, COL);    //打印出最终结果的棋子分布情况
}

最终代码：

我们将代码分为一个头文件和两个源文件：

头文件：game.h

用于定义宏、元素声明、头文件引用

#define ROW 3
#define COL 3
#include <stdio.h>
#include <time.h>
#include <stdlib.h>


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

//打印棋盘的声明
void display_board(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);

//判断胜负的声明
char is_win(char board[ROW][COL], int row, int col);
//翻译字符
void read_char(char ret);

源文件：game.c

函数的定义

#include "game.h"

//初始化棋盘的函数
void init_board(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] = ' ';
		}
	}
}

//打印棋盘的函数
void display_board(char board[ROW][COL], int row, int col)
{
	int i = 0;

	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			printf(" %c ", board[i][j]);
			if (j < col - 1)
				printf("|");
		}
		printf("\n");
		if (i < row - 1)
		{
			int j = 0;
			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("请玩家下棋\n请输入下棋的坐标:>");
	int n, m;
	while (1)
	{
		scanf("%d%d", &n, &m);
		if (board[n - 1][m - 1] != ' ')
		{
			printf("该坐标已被占用，请重新输入:>");
		}
		else
			break;
	}
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			if (i == n - 1 && j == m - 1)
			{
				board[i][j] = '*';
			}
		}
	}
}

//电脑下棋的函数  //#
void computer_move(char board[ROW][COL], int row, int col)
{
	int n = 0;
	int m = 0;
	while (1)
	{
		n = rand() % ROW;
		m = rand() % COL;
		if (board[n][m] != ' ')
			;
		else
			break;
	}
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			if (i == n && j == m)
			{
				board[i][j] = '#';
			}
		}
	}
}

//判断胜负的函数
char is_win(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	//判断行
	for (i = 0; i < row; i++)
	{
		int conut1 = 0;
		int conut2 = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == '*')
			{
				conut1++;
			}
			else if (board[i][j] == '#')
			{
				conut2++;
			}
		}
		if (conut1 == col)
		{
			return '*';
		}
		if (conut2 == col)
		{
			return '#';
		}
	}
	//判断列
	for (j = 0; j < col; j++)
	{
		int conut1 = 0;
		int conut2 = 0;
		for (i = 0; i < row; i++)
		{
			if (board[i][j] == '*')
			{
				conut1++;
			}
			else if (board[i][j] == '#')
			{
				conut2++;
			}
		}
		if (conut1 == row)
		{
			return '*';
		}
		if (conut2 == row)
		{
			return '#';
		}
	}
	//判断正对角线
	int conut1 = 0;
	int conut2 = 0;
	for (i = 0; i < row; i++)
	{
		if (board[i][i] == '*')
		{
			conut1++;
		}
		else if (board[i][i] == '#')
		{
			conut2++;
		}
	}
	if (conut1 == row)
	{
		return '*';
	}
	if (conut2 == row)
	{
		return '#';
	}
	//判断反对角线
	conut1 = 0;
	conut2 = 0;
	for (i = 0; i < row; i++)
	{
		if (board[i][row - 1 - i] == '*')
		{
			conut1++;
		}
		else if (board[i][row - 1 - i] == '#')
		{
			conut2++;
		}
	}
	if (conut1 == row)
	{
		return '*';
	}
	if (conut2 == row)
	{
		return '#';
	}
	//判断平局
	int conut3 = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
			{
				conut3++;
			}
		}
	}
	if (conut3 == 0)
	{
		return 'q';
	}
	return 'c';
}
//翻译字符
void read_char(char is)
{
	if (is == '*')
	{
		printf("玩家赢了\n");
	}
	else if (is == '#')
	{
		printf("电脑赢了\n");
	}
	else
	{
		printf("平局\n");
	}
}

源文件：test.c

N子棋整体逻辑

#include "game.h"

void menu()
{
	printf("       1.play          \n");
	printf("       0.exit          \n");
}
void game()
{
	char board[ROW][COL] = { 0 };
	//初始化棋盘
	init_board(board, ROW, COL);
	//打印棋盘
	display_board(board, ROW, COL);
	char is = '0';
	while (1)
	{
		//玩家下棋  //*
		player_move(board, ROW, COL);
		//判断胜负
		is = is_win(board, ROW, COL);
		if (is != 'c')
		{
			break;
		}
		//电脑下棋  //#
		computer_move(board, ROW, COL);
		//判断胜负
		is = is_win(board, ROW, COL);
		if (is != 'c')
		{
			break;
		}
		//打印
		display_board(board, ROW, COL);
	}
	//清除界面
	system("cls");
	//翻译字符
	read_char(is);
	//打印
	display_board(board, ROW, COL);
}
int main()
{
	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("选择错误，请重新选择:>");
			break;
		}
	} while (input);
	return 0;
}

总结：

其实每个语句都不难，但是整体组合在一起就显得比较复杂，我们只需要一点点分析，用逻辑将他们联合起来就成功了！

最后，希望这篇文章可以帮助到大家，喜欢的话记得三连哦~

关注博主，后续会持续推迟优质内容~

感谢大家的支持~ 

蒲公英的吴
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论
专栏目录
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

蒲公英的吴

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值