服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - C/C++ - C语言实现井字棋(三子棋)

C语言实现井字棋(三子棋)

2021-11-03 14:28mac_timmy C/C++

这篇文章主要为大家详细介绍了C语言实现井字棋游戏,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

本文实例为大家分享了C语言实现井字棋的具体代码,供大家参考,具体内容如下

一、实现思路

1、初始化数组

三子棋是九宫格的格式,所以用二维数组接收数据。用‘O'代表电脑下的子,‘X'代表玩家下的子。未下子的时候初始化 ' ‘(space)。则二维数组为“char”类型,大小为char board[3][3]。

2、打印棋盘

打印出井字的棋盘,同时为了将数据显示在每格的中间,用空格隔开(“ %c |”)的格式设置棋盘“|”用来形成竖,接着打印“- - -|”用来形成行。将两部用for循环按照逻辑链接起来,即可打印出“井”。同时“%c”处初始化为‘ '(space)

3、玩家下子

<1> 玩家下的子用数组的坐标表示,输入提示:(请输入坐标:),输入格式为(1 1),范围为1~3。
<2> 玩家下子的时候,如果遇到已经下过子的坐标,返回并提示错误,重新输入。
<3> 如果输入的坐标超过范围,提示错误,重新输入。
<4> 打印棋盘,将玩家下子的坐标处用'X'替换。

4、电脑下子

<1> 电脑下子,利用范围为1~3,随机产生条件下的坐标,如果遇到已经下过子的坐标,就重新产生条件下的坐标,这里利用循环进行调试。

<2> 有一个电脑下子优先规则:

a、电脑下子的第一个是随机产生,在电脑先手的时候,第二个也是随机产生。
b、判断是否有两个 ‘O”O' 在行、列或者斜对角,如果有,就将第三个子下在可以连成一直线的空白处(即三点成线,赢得比赛)。如果有连成线但是没用空白处,进行 c 步骤。
c、判断是不是有两个 ‘X”X' 在行、列或者斜对角练成线,并且第三个空为空白。如果有就将子下在该空白处(即对玩家进行堵截)。如果没用,进行 d 步骤。
d、在范围内随机下子。  

<3> 打印棋盘,将电脑下子的坐标处用'O'代替。

5、输赢判断

当判断出有行、列或者斜对角出现 ‘X' ‘O' 三点成线,输出判断(恭喜你,你赢了)(很遗憾,你输了)并退出游戏,如果遍历数组发现不符合上述要求,而且没有数据 ' ‘(space)(即棋盘下满),输出(和棋)并退出游戏。

6、逻辑关系

开始游戏——选择电脑先手——(ComputerGo——PrintfGame——IsWin——PlayGo——PrintfGame——IsWin)(循环实现)

开始游戏——选择玩家先手——PrintfGame——(PlayGo——PrintfGame——IsWin——ComputerGo——PrintfGame——IsWin)(循环实现)

二、源代码

1、game.h(头文件)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#ifndef __game_h__
#define __game_h__
 
 
#define ROW 3 //标识符定义行ROW = 3
#define COL 3//标识符定义列COL = 3
 
 
void InitGame(char arr[ROW][COL], int row, int col);//初始化
void PrintfGame(char arr[ROW][COL], int row, int col);//打印
void Menu();//菜单
void ComputerGo(char arr[ROW][COL], int row, int col);//电脑走
void PlayGo(char arr[ROW][COL], int row, int col);//玩家走
char IsWin(char arr[ROW][COL], int row, int col);//输、赢、和局
 
#endif  //__game_h__

2、game.c(函数定义)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
#define _CRT_SECURE_NO_WARNINGS 1
 
#include "game.h"   //引用自定义头文件
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
 
 
void Menu()
{
    printf("**********************************\n");
    printf("*********     1.paly     *********\n");
    printf("*********     0.exit     *********\n");
    printf("**********************************\n");
}
 
 
 
void InitGame(char arr[ROW][COL],int row, int col)//初始化数组
{
    int i = 0;
    int j = 0;
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COL; j++)
        {
            arr[i][j] = ' '// 利用循环将数组元素初始化为' '(space)
        }
    }
}
 
 
void PrintfGame(char arr[ROW][COL], int row, int col)//打印棋盘
{
//利用循环打印棋盘
    int i = 0;
    int j = 0;
    for (i = 0; i < ROW; i++)//限定范围,不超过ROW
    {
        if (i < ROW - 1) //打印前两行
        {
            for (j = 0; j < COL; j++)
            {
                if (j < COL - 1) //打印前两列
                {
                    printf(" %c |", arr[i][j]);
                }
                else
                {
                    printf(" %c ",arr[i][j]); //打印第三列
                }
            }
            printf("\n");    //输出形式为" %c | %c | %c "
 
            for (j = 0; j < COL; j++)
            {
                if (j < COL - 1)
                {
                    printf("---|");  //打印前两列
                }
                else
                {
                    printf("---");  //打印第三列
                }
            }
            printf("\n");    //输出形式为"---|---|---"
        }
 
        else    //打印第三行
        {
            for (j = 0; j < COL; j++)
            {
                if (j < COL - 1)
                {
                    printf(" %c |",arr[i][j]);
                }
                else
                {
                    printf(" %c ",arr[i][j]);
                }
            }
            printf("\n");  //输出形式为 " %c | %c | %c "
        }
    }
}
 
 
 
void PlayGo(char arr[ROW][COL], int row, int col)//玩家走
{
    int i = 0;
    int j = 0;
    int set = 0;
    do
    {
        printf("\n");
        printf("请输入坐标:>");
 
        scanf("%d %d", &i, &j);
        printf("\n");
        //对输入的i,j减1,用户输入的时候就可以直接以(1 1)为第一个输入点
        i--;
        j--;
 
        if ((i<0) || (i>=row) || (j<0) || (j>=col) || (arr[i][j] != ' '))
        {//输入超出了范围或者输入坐标处已经有棋子
            printf("输入有误!\n");
            set = 1;
        }
        else
        {
            arr[i][j] = 'X';//玩家下子
            set = 0;
        }
    } while (set);//没有下子成功就循环到输入成功
}
 
 
 
char IsWin(char arr[ROW][COL], int row, int col)//判断输赢
{
    int i = 0;
    int j = 0;
    int count = 0;
 
    for (i = 0; i < ROW; i++)
    {
        if ((arr[i][0] == arr[i][1]) && (arr[i][1] == arr[i][2]) && (arr[i][0] != ' '))
        {
            return 'X';//产生有行成线,返回'X'
        }
    }
    for (i = 0; i < ROW; i++)
    {
        if ((arr[0][i] == arr[1][i]) && (arr[1][i] == arr[2][i]) && (arr[0][i] != ' '))
        {
            return ' ';//产生列成线,返回' '
        }
    }
    if ((arr[0][0] == arr[1][1]) && (arr[1][1] == arr[2][2]) && (arr[1][1] != ' ') ||
        (arr[2][0] == arr[1][1]) && (arr[1][1] == arr[0][2])&&(arr[1][1]!=' '))
    {
        return 'O';//产生斜对角成线,返回'O'
    }
    if ((arr[0][0] != ' ') && (arr[0][1] != ' ') && (arr[0][2] != ' ') &&
        (arr[1][0] != ' ') && (arr[1][1] != ' ') && (arr[1][2] != ' ') &&
        (arr[2][0] != ' ') && (arr[2][1] != ' ') && (arr[2][2] != ' '))
    {
        return 'H';//棋盘已经下满却还没有胜负产生,返回'H'
    }
    return 0;
}
 
 
 
void ComputerGo(char arr[ROW][COL], int row, int col)//电脑走
{
    int i = 0;
    int j = 0;
 
    int flag0 = 0;//flage0 用于限制一旦有一种判断成功,就不再进行其他判断
    int flag2 = 0;//flage2 用于对电脑即将赢的时候,不同判断产生后,进入不同的case
    int flag3 = 0;//flage3 用于对玩家即将赢的时候,不同判断产生后,进入不同的case
 
//电脑还差一子就赢得比赛的情况
    if (flag0 == 0)
    {
        for (i = 0; i < ROW; i++)//每行有两个‘O'‘O'连在一起,就在第三个空格处下子
        {
            if ((arr[i][0] == arr[i][1] && arr[i][0] == 'O'&&arr[i][2] != 'X')
                || (arr[i][1] == arr[i][2] && arr[i][1] == 'O'&&arr[i][0] != 'X')
                || (arr[i][0] == arr[i][2] && arr[i][0] == 'O'&&arr[i][1] != 'X'))
            {
                flag0 = 1;
                flag2 = 1;
                break;
            }
        }
    }
 
 
    if (flag0 == 0)
    {
        for (j = 0; j < ROW; j++)//每列有两个‘O'‘O'连在一起,就在第三个空格处下子
        {
            if ((arr[0][j] == arr[1][j] && arr[0][j] == 'O'&&arr[2][j] != 'X')
                || (arr[1][j] == arr[2][j] && arr[1][j] == 'O'&&arr[0][j] != 'X')
                || (arr[0][j] == arr[2][j] && arr[0][j] == 'O'&&arr[1][j] != 'X'))
            {
                flag2 = 2;
                flag0 = 1;
                break;
            }
        }
    }
 
 
    if ((arr[0][0] == arr[1][1] && arr[0][0] == 'O'&&arr[2][2] != 'X')//第一条斜对角
        || (arr[1][1] == arr[2][2] && arr[1][1] == 'O'&&arr[0][0] != 'X')
        || (arr[0][0] == arr[2][2] && arr[0][0] == 'O'&&arr[1][1] != 'X')
        &&(flag0 == 0))
    {
        flag2 = 3;
        flag0 = 1;
    }
 
    if ((arr[0][2] == arr[1][1] && arr[0][2] == 'O'&&arr[2][0] != 'X')//第二条斜对角
        || (arr[1][1] == arr[2][0] && arr[1][1] == 'O'&&arr[0][2] != 'X')
        || (arr[0][2] == arr[2][0] && arr[0][2] == 'O'&&arr[1][1] != 'X')
        && (flag0 == 0))
    {
        flag2 = 4;
        flag0 = 1;
    }
 
    switch (flag2)
    {
    case 1:
        do
        {
            j = rand() % 3;//固定行不变,改变列,让棋子进入空白处
            if (arr[i][j] == ' ')
            {
                arr[i][j] = 'O';
                break;
            }
        } while (1);
        break;
 
    case 2:
        do
        {//rand()%3 产生0 1 2 之间的随机数
            i = rand() % 3;//固定列不变,改变行,让棋子进入空白处
            if (arr[i][j] == ' ')
            {
                arr[i][j] = 'O';
                break;
            }
        } while (1);
        break;
 
    case 3:
        do
        {//改变行列,但是限制(行数=列数),使其在第一条斜对角空白处下子
            i = rand() % 3;
            j = rand() % 3;
            if ((i == j) && (arr[i][j] == ' '))
            {
                arr[i][j] = 'O';
                break;
            }
        } while (1);
        break;
 
    case 4:
        do
        {//改变行列,但是限制行数和列数,使其在第二条斜对角空白处下子
            i = rand() % 3;
            j = rand() % 3;
            if ((i == j) && (arr[i][j] == ' ') && (i == 1) ||
                        (i == j + 2) && (arr[i][j] == ' ') ||
                        (j == i + 2) && (arr[i][j] == ' '))
            {
                arr[i][j] = 'O';
                break;
            }
        } while (1);
        break;
    }
 
//玩家还差一子就赢得比赛的时候,电脑进行堵截
    if (flag0 == 0)
    {
        for (i = 0; i < ROW; i++)//每行有两个‘X'‘X'连在一起,就在第三个空格处下子
        {
            if ((arr[i][0] == arr[i][1] && arr[i][0] == 'X'&&arr[i][2] != 'O')
                || (arr[i][1] == arr[i][2] && arr[i][1] == 'X'&&arr[i][0] != 'O')
                || (arr[i][0] == arr[i][2] && arr[i][0] == 'X'&&arr[i][1] != 'O'))
            {
                flag3 = 1;
                flag0 = 1;
                break;
            }
        }
    }
 
 
    if (flag0 == 0)
    {
        for (j = 0; j < ROW; j++)//每列有两个‘X'‘X'连在一起,就在第三个空格处下子
        {
            if ((arr[0][j] == arr[1][j] && arr[0][j] == 'X'&&arr[2][j] != 'O')
                || (arr[1][j] == arr[2][j] && arr[1][j] == 'X'&&arr[0][j] != 'O')
                || (arr[0][j] == arr[2][j] && arr[0][j] == 'X'&&arr[1][j] != 'O'))
            {
                flag3 = 2;
                flag0 = 1;
                break;
            }
        }
    }
 
 
    if ((arr[0][0] == arr[1][1] && arr[0][0] == 'X'&&arr[2][2] != 'O')//斜对角
        || (arr[1][1] == arr[2][2] && arr[1][1] == 'X'&&arr[0][0] != 'O')
        || (arr[0][0] == arr[2][2] && arr[0][0] == 'X'&&arr[1][1] != 'O')
        && (flag0 == 0))
    {
        flag3 = 3;
        flag0 = 1;
    }
 
    if ((arr[0][2] == arr[1][1] && arr[0][2] == 'X'&&arr[2][0] != 'O')//斜对角
        || (arr[1][1] == arr[2][0] && arr[1][1] == 'X'&&arr[0][2] != 'O')
        || (arr[0][2] == arr[2][0] && arr[0][2] == 'X'&&arr[1][1] != 'O')
        && (flag0 == 0))
    {
        flag3 = 4;
        flag0 = 1;
    }
 
    switch (flag3)
    {
    case 1:
        do
        {
            j = rand() % 3;
            if (arr[i][j] == ' ')
            {
                arr[i][j] = 'O';
                break;
            }
        } while (1);
        break;
 
    case 2:
        do
        {
            i = rand() % 3;
            if (arr[i][j] == ' ')
            {
                arr[i][j] = 'O';
                break;
            }
        } while (1);
        break;
 
    case 3:
        do
        {
            i = rand() % 3;
            j = rand() % 3;
            if ((i == j) && (arr[i][j] == ' '))
            {
                arr[i][j] = 'O';
                break;
            }
        } while (1);
        break;
 
    case 4:
        do
        {
            i = rand() % 3;
            j = rand() % 3;
            if ((i == j) && (arr[i][j] == ' ') && (i == 1) ||
                        (i == j + 2) && (arr[i][j] == ' ') ||
                        (j == i + 2) && (arr[i][j] == ' '))
            {
                arr[i][j] = 'O';
                break;
            }
        } while (1);
        break;
    }
 
//无论是玩家还是电脑,没有即将三子成线的情况,电脑随机产生一个棋子
    if (flag0 == 0)
    {
        do
        {
            i = rand() % 3;
            j = rand() % 3;
 
            if (arr[i][j] == ' ')
            {
                arr[i][j] = 'O';
                break;
            }
        } while (1);
    }
}

3、text.c(逻辑及调用)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
#define _CRT_SECURE_NO_WARNINGS 1
 
#include "game.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
 
void game1(char arr[ROW][COL], int row, int col)//电脑先手
{
    char i = 0;
 
    while (1)//只有玩家赢或者电脑赢或者棋盘满了才退出循环
    {
        printf("\n");
 
        ComputerGo(arr, row, col);//电脑走
        PrintfGame(arr, row, col);//打印棋盘
        i = IsWin(arr, row, col);//判断是否有输赢
        if ((i == 'X') || (i == 'O') || (i == ' '))
        {//电脑下子之后,满足有三子成线,一定是电脑赢
            printf("电脑赢!\n");
            printf("\n");
 
            break;
        }
        else if (i == 'H')//棋盘已满
        {
            printf("和局!\n");
            printf("\n");
 
            break;
        }
        PlayGo(arr, row, col);//玩家走
        PrintfGame(arr, row, col);//打印棋盘
        i = IsWin(arr, row, col);//判断输赢
        if ((i == 'X') || (i == 'O') || (i == ' '))
        {//玩家下子之后,满足有三子成线,一定是玩家赢
            printf("玩家赢!\n");
            printf("\n");
 
            break;
        }
        else if (i == 'H')//棋盘已满
        {
            printf("和局!\n");
            printf("\n");
 
            break;
        }
    }
}
 
void game2(char arr[ROW][COL], int row, int col)//玩家先手
{
    char i = 0;
    int tmp = 0;
 
    while (1)
    {
 
        if (tmp == 0)//玩家下棋之前打印一个空白棋盘,只执行一次
        {
            printf("\n");
            PrintfGame(arr, row, col);
            tmp = 1;
        }
 
        PlayGo(arr, row, col);
        PrintfGame(arr, row, col);
        printf("\n");
 
        i = IsWin(arr, row, col);
        if ((i == 'X') || (i == 'O') || (i == ' '))
        {
            printf("玩家赢!\n");
            printf("\n");
 
            break;
        }
        else if (i == 'H')
        {
            printf("和局!\n");
            printf("\n");
 
            break;
        }
        ComputerGo(arr, row, col);
        PrintfGame(arr, row, col);
        i = IsWin(arr, row, col);
        if ((i == 'X') || (i == 'O') || (i == ' '))
        {
            printf("电脑赢!\n");
            printf("\n");
 
            break;
        }
        else if (i == 'H')
        {
            printf("和局!\n");
            printf("\n");
 
            break;
        }
    }
}
 
 
//main函数
int main()
{
    int i = 0;
    int j = 0;
    int input = 0;
    int tmp = 0;
    int row = 3;
    int col = 3;
    char arr[3][3];
    srand((unsigned int)time(NULL));//随机数发生器,用于产生随机数的时候,每次都不一样
    do
    {
        Menu();//打印
        printf("请选择:>\n");
        scanf("%d", &input);
        printf("\n");
        switch (input)
        {
        case 1:
 
            InitGame(arr, row, col);//初始化函数
            do
            {
                printf("请选择:>\n1.电脑先手  2.玩家先手\n");
                scanf("%d", &tmp);
                switch (tmp)
                {
                case 1:
                    game1(arr, row, col);//电脑先手
                    tmp = 0;
                    break;
                case 2:
                    game2(arr, row, col);//玩家先手
                    tmp = 0;
                    break;
                default:
                    printf("输入有误! 请重新输入:>\n\n");
                    break;
                }
            } while (tmp);
            break;
 
        case 0:
            printf("游戏退出!\n");
            break;
 
        default:
            printf("输入有误!\n");
            break;
        }
    } while (input);
 
    system("pause");
    return 0;
}

三、程序截图

C语言实现井字棋(三子棋)

C语言实现井字棋(三子棋)

C语言实现井字棋(三子棋)

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持服务器之家。

原文链接:https://blog.csdn.net/Mac_timmy/article/details/75674684

延伸 · 阅读

精彩推荐