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

119 阅读 0 评论 79 点赞

我是靠谱客的博主幸福毛衣，最近开发中收集的这篇文章主要介绍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(头文件)

#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(函数定义)

#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(逻辑及调用)

#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("输入有误! 请重新输入:>nn");
                    break;
                }
            } while (tmp);
            break;

        case 0:
            printf("游戏退出!n"); 
            break;

        default:
            printf("输入有误!n");
            break;
        }
    } while (input);

    system("pause");
    return 0;
}