C语言项目复盘：五子棋胜负判断算法优化实战

五子棋作为经典的策略游戏，其胜负判断逻辑看似简单，实则暗藏算法优化的精妙之处。很多初学者在实现基础功能后，往往止步于"能用就行"的阶段，却错过了提升代码质量和算法思维的绝佳机会。本文将带你深入一个已完成五子棋项目的核心模块，聚焦胜负判断算法的优化过程，从暴力遍历到局部搜索，再到位运算的极致优化，完整呈现一个C语言项目的重构思路。

1. 从全局遍历到局部搜索的算法跃迁

初学者的五子棋胜负判断常采用最直观的全局遍历法：每次落子后检查整个棋盘是否存在五子连线。这种实现虽然逻辑简单，但存在明显的性能缺陷——无论棋盘状态如何变化，都需要完整扫描15×15的二维数组。

c复制// 典型全局遍历判赢算法（不推荐）
int isWin_global(int board[15][15]) {
    for(int i=0; i<15; i++) {
        for(int j=0; j<15; j++) {
            if(checkFive(board, i, j)) 
                return board[i][j];
        }
    }
    return 0;
}

优化突破口在于观察五子棋的核心规则：新落子才是可能形成五连的唯一源头。基于此，我们可以将算法复杂度从O(n²)降至O(1)，只需从最新落子点向四个方向辐射检查：

c复制// 优化后的局部搜索算法
int isWin_local(int board[15][15], int x, int y) {
    int directions[4][2] = {{1,0}, {0,1}, {1,1}, {1,-1}}; // 横、竖、斜
    for(int i=0; i<4; i++) {
        int count = 1;
        // 正向搜索
        for(int step=1; step<5; step++) {
            int nx = x + directions[i][0]*step;
            int ny = y + directions[i][1]*step;
            if(nx>=0 && nx<15 && ny>=0 && ny<15 && board[nx][ny]==board[x][y])
                count++;
            else break;
        }
        // 反向搜索
        for(int step=1; step<5; step++) {
            int nx = x - directions[i][0]*step;
            int ny = y - directions[i][1]*step;
            if(nx>=0 && nx<15 && ny>=0 && ny<15 && board[nx][ny]==board[x][y])
                count++;
            else break;
        }
        if(count >= 5) return board[x][y];
    }
    return 0;
}

性能对比测试结果：

提示：实际测试中，局部搜索算法在中盘阶段的性能优势可达30-50倍

2. 数据结构与位运算的深度优化

当算法优化到局部搜索层面后，我们还可以通过改进数据表示方式获得额外性能提升。传统二维数组存储方式虽然直观，但存在内存访问效率问题。

位棋盘表示法将整个棋盘编码为两个无符号长整型（黑白各一个），每个bit代表一个棋盘位置的状态：

c复制#define BOARD_SIZE 15
typedef struct {
    uint64_t black; // 黑子位置
    uint64_t white; // 白子位置
} BitBoard;

// 落子操作转化为位运算
void makeMove(BitBoard *board, int x, int y, int player) {
    uint64_t mask = 1ULL << (x*BOARD_SIZE + y);
    if(player == 1) board->black |= mask;
    else board->white |= mask;
}

位运算判赢算法通过预定义的掩码模式实现极速检查：

c复制// 预定义五连模式掩码
const uint64_t win_patterns[] = {
    0x1F,        // 水平五连
    0x1FULL<<0, 0x1FULL<<5, ..., // 垂直五连
    // 斜向模式省略...
};

int isWin_bitboard(BitBoard *board, int player) {
    uint64_t stones = (player == 1) ? board->black : board->white;
    for(int i=0; i<sizeof(win_patterns)/sizeof(uint64_t); i++) {
        if((stones & win_patterns[i]) == win_patterns[i])
            return player;
    }
    return 0;
}

优化效果对比：

3. 模块化重构与代码可维护性

算法优化之后，我们需要关注代码的组织结构。原始实现往往将所有功能堆砌在main函数中，不利于后续维护和扩展。

模块化设计将系统分解为几个高内聚的组件：

code复制五子棋模块化结构
├── board.c        # 棋盘状态管理
├── logic.c        # 游戏规则与胜负判断
├── render.c       # 图形渲染
└── ai.c           # AI算法(可选)

关键接口设计示例：

c复制// board.h
typedef struct {
    BitBoard bitboard;
    int current_player;
    int last_move_x, last_move_y;
} GameState;

void initGame(GameState *game);
int isValidMove(GameState *game, int x, int y);
void makeMove(GameState *game, int x, int y);

// logic.h
int checkWin(GameState *game);
int evaluatePosition(GameState *game); // 为AI做准备

重构后的主程序逻辑变得清晰简洁：

c复制int main() {
    GameState game;
    initGame(&game);
    
    while(1) {
        Position move = getHumanMove(); // 获取玩家输入
        if(isValidMove(&game, move.x, move.y)) {
            makeMove(&game, move.x, move.y);
            if(checkWin(&game)) {
                showWinner(game.current_player);
                break;
            }
            game.current_player = 3 - game.current_player; // 切换玩家
        }
    }
    return 0;
}

4. 性能测试与优化验证

为确保优化效果真实可靠，需要建立系统的测试框架。我们可以设计三类测试场景：

1. 基准测试：测量各算法在相同棋盘状态下的执行时间
2. 边界测试：检查棋盘边缘和角落的特殊情况
3. 压力测试：模拟高频率连续调用场景

测试用例示例（使用Criterion测试框架）：

c复制#include <criterion/criterion.h>
#include "logic.h"

Test(win_check, horizontal_win) {
    GameState game;
    initGame(&game);
    // 制造水平五连
    for(int i=0; i<5; i++) 
        makeMove(&game, 7, 3+i, 1);
    cr_assert_eq(checkWin(&game), 1);
}

Test(performance, bitboard_vs_array) {
    GameState games[2];
    // 初始化两个游戏状态（位棋盘和数组实现）
    
    clock_t start = clock();
    for(int i=0; i<10000; i++) {
        checkWin_array(&games[0]);
    }
    double array_time = (double)(clock()-start)/CLOCKS_PER_SEC;
    
    start = clock();
    for(int i=0; i<10000; i++) {
        checkWin_bitboard(&games[1]);
    }
    double bitboard_time = (double)(clock()-start)/CLOCKS_PER_SEC;
    
    cr_assert(bitboard_time < array_time*0.5);
}

优化前后的关键指标对比：

在实现这些优化后，一个有趣的发现是：当算法效率提升到微秒级后，图形渲染反而成为了新的性能瓶颈。这提醒我们优化应该针对真正的热点，而不是盲目追求局部极致。