分段错误 - 数组越界

Question

我编写了一个简单的算法，这样当用户输入一个 int N 时，它会创建一个 N×N 网格，其中在同一行或同一列中没有重复项。该算法有时适用于较小的数字，但通常会引发分段错误。错误发生在设置网格数组元素的行中的 noRowDuplicates 函数中。

我不确定为什么会发生这种情况，希望能提供任何帮助。提前致谢！

// Author: Eric Benjamin
// This problem was solved using recursion. fill() is the recursive function.


#include <iostream>
#include <cstdlib>
#include <time.h>

using namespace std;

void fillOptions();
void fill(int arrayPosition);
int inputNum;
int gridSize;
int *grid;
int allOptionsSize = 0;
int *allOptions;

int main() {
    cout << "Please enter a number!" << endl;
    cin >> inputNum;
    gridSize = inputNum * inputNum;

    grid = new int[gridSize];
    allOptions = new int[inputNum];
    for (int i = 0; i < inputNum; i++) {
         allOptions[i] = i + 1;
         allOptionsSize++;
    }

    srand((unsigned)time(0));
    fill(0);

    delete[] grid;
    delete[] allOptions;
    return 0;
}

bool noColumnDuplicates(int arrPosition, int valueToCheck) {
    for (int i = 1; i < inputNum; i++) {
        if (arrPosition - (inputNum * i) >= 0) {
            if (grid[arrPosition - (inputNum * i)] == valueToCheck) {
                return false;
            }
        }
    }
    return true;
}

bool noRowDuplicates(int arrPosition, int valueToCheck) {
    int rowPosition = arrPosition % inputNum; // 0 to num - 1
    if (rowPosition > 0) {
        for (int p = 1; p < rowPosition + 1; p++) {
            if (grid[arrPosition - p] == valueToCheck) {
                return false;
            }
        }
    }
    return true;
}

void fill(int arrayPosition) {
    if (arrayPosition < gridSize) {
        int randomPosition = rand() % allOptionsSize;
        grid[arrayPosition] = allOptions[randomPosition];
        if (noColumnDuplicates(arrayPosition, grid[arrayPosition])) {
            if (noRowDuplicates(arrayPosition, grid[arrayPosition])) {
                if (arrayPosition % inputNum == 0) {
                    cout << endl;
                }
                cout << grid[arrayPosition] << " ";
                fill(arrayPosition + 1);
            } else {
                fill (arrayPosition);
            }
        } else {
            fill(arrayPosition);
        }
    }
}

Answer 1

您对 fill() 的初始调用将为其参数传递 0，arrayPosition。

gridSize 是矩阵/数组的大小。

如果您检查fill() 中的逻辑，您将得出结论，除非arrayPosition 等于或大于gridSize，否则将递归调用fill()，arrayPosition 要么是相同，或增加 1。

通过fill() 的所有逻辑执行路径，当arrayPosition < gridSize 时，会导致对fill() 的递归调用。

换句话说，例如，如果您的数组/矩阵有一万个值，您的 fill() 将尝试对其自身进行至少（并且可能更多）一万次嵌套递归调用！

这不会有好的结局。当您的代码超出您的操作系统分配给它的最大堆栈空间量时，您的代码会遇到分段错误，并且您的操作系统拒绝为您的进程分配更多的堆栈空间。

您需要重构您的逻辑，以避免这种失控的递归。不幸的是，堆栈空间不是无限的。显示的逻辑在 C++ 中根本被破坏。您不能依赖编译器消除尾递归，并避免每次递归函数调用都消耗堆栈空间。

一个简短的评论表明嵌套递归可以简单地替换为while 循环。整体算法还有一些改进的空间，但至少这会解决递归问题。