递归实现三角形迷宫最短路径时是否应使用全局变量？

先直接给结论：递归场景下应该尽量避免使用全局变量，你的两个全局变量都有更优的替代方案，完全不需要依赖全局空间。

一、处理moves全局数组 #

moves是固定的方向偏移量，属于只读常量数据，不需要作为参数传递（确实会增加栈开销），也不需要放在全局作用域。你可以把它改成文件静态常量，既不会污染全局命名空间，也不会占用栈空间：

// 放在文件顶部，仅当前文件可见
static const char moves[2][3][2] = {
    {{0,-1}, {0,1}, {-1,0}},
    {{0,-1}, {0,1}, {1,0}}
};

静态常量存储在全局数据区，所有递归调用都可以直接访问，同时限制了作用域，比全局变量更安全。

二、移除foundExit全局变量 #

这个变量用于标记是否找到出口，需要在递归调用链中共享状态，有两种可靠的替代方案：

方案1：让函数返回状态（推荐）

把shortestPath的返回类型从void改为bool，找到出口时返回true，否则返回false。上层调用根据返回值决定是否终止后续递归分支：

bool shortestPath(Map map, int r, int c, char direction) {
    // 检测到出口，返回true
    if (r < 0 || r >= map.rows || c < 0 || c >= map.cols) {
        return true;
    }

    // 原有的单行移动逻辑不变
    while (map.cells[map.cols * r + c] == 3) {
        r += moves[(r+c) & 1][direction][0];
        c += moves[(r+c) & 1][direction][1];
        if (r < 0 || r >= map.rows || c < 0 || c >= map.cols) {
            return true;
        }
    }

    if ((map.cells[map.cols * r + c] ^ (1 << InvertDirection(direction))) == 0b111) {
        return false;
    }

    printf("%d,%d\n", r+1, c+1);

    // 遍历方向，递归调用
    for (char direc = 0; direc < 3; direc++) {
        if (!(map.cells[map.cols * r + c] & (1 << direc)) && (direc != InvertDirection(direction))) {
            // 若递归找到出口，立即向上传递true
            if (shortestPath(map, r + moves[(r+c)&1][direc][0], c + moves[(r+c)&1][direc][1], direc)) {
                return true;
            }
        }
    }
    return false;
}

main中的调用逻辑修改为：

for (char direc = 0; direc < 3; direc++) {
    if (!(map.cells[map.cols * rows + cols] & (1 << direc))) {
        if (shortestPath(map, rows, cols, direc)) {
            break; // 找到出口就终止其他分支
        }
    }
}

方案2：传递布尔值指针

如果不想修改函数返回值，可以在main中声明局部变量，通过指针传递给递归函数，实现状态共享：

void shortestPath(Map map, int r, int c, char direction, bool *foundExit) {
    if (*foundExit) return; // 已找到出口，直接返回

    if (r < 0 || r >= map.rows || c < 0 || c >= map.cols) {
        *foundExit = true;
        return;
    }

    // 原有的单行移动逻辑不变
    while (map.cells[map.cols * r + c] == 3) {
        r += moves[(r+c) & 1][direction][0];
        c += moves[(r+c) & 1][direction][1];
        if (r < 0 || r >= map.rows || c < 0 || c >= map.cols) {
            *foundExit = true;
            return;
        }
    }

    if ((map.cells[map.cols * r + c] ^ (1 << InvertDirection(direction))) == 0b111) {
        return;
    }

    printf("%d,%d\n", r+1, c+1);

    // 遍历方向，递归调用
    for (char direc = 0; direc < 3; direc++) {
        if (*foundExit) break;
        if (!(map.cells[map.cols * r + c] & (1 << direc)) && (direc != InvertDirection(direction))) {
            shortestPath(map, r + moves[(r+c)&1][direc][0], c + moves[(r+c)&1][direc][1], direc, foundExit);
        }
    }
}

main中的调用逻辑修改为：

bool foundExit = false;
for (char direc = 0; direc < 3; direc++) {
    if (foundExit) break;
    if (!(map.cells[map.cols * rows + cols] & (1 << direc))) {
        shortestPath(map, rows, cols, direc, &foundExit);
    }
}

三、核心问题总结 #

递归场景下使用全局变量的弊端非常明显：

• 全局变量的状态会被所有递归调用共享，一旦逻辑出错，很难定位是哪个调用分支修改了状态；
• 代码耦合度高，函数无法独立复用，也不支持多线程场景；
• 调试难度大，递归调用栈的状态和全局变量的状态交织在一起，难以追踪。

只有当数据是只读的全局常量时，才可以考虑用static const限制作用域的方式替代全局变量；而像foundExit这种需要修改的共享状态，一定要用参数传递（指针或返回值）的方式处理，保证递归逻辑的清晰和可维护性。

内容的提问来源于stack exchange，提问作者demon