有人知道力扣汉诺塔用c语言怎么写吗

Question

一直报错，其他语言都可以通过，就c语言不行，每次都显示heap-buffer-overflow，怎么修改都不行

void hanotaRecursive(int n, int* A, int* B, int* C, int* sizes[3], int capacities[3]) {
    if (n <= 0) return;

    // Move n-1 disks from A to B using C
    hanotaRecursive(n - 1, A, C, B, sizes, capacities);

    // Move the nth disk from A to B
    if (sizes[0][0] == 0 || sizes[1][0] >= capacities[1]) return;
    int disk = A[sizes[0][0] - 1];
    sizes[0][0]--;
    B[sizes[1][0]] = disk;
    sizes[1][0]++;

    // Move n-1 disks from B to C using A
    hanotaRecursive(n - 1, B, A, C, sizes, capacities);
}

void hanota(int* A, int ASize, int* B, int BSize, int* C, int CSize) {
    int capacities[3] = {ASize, ASize, ASize};
    int sizes_array[3] = {ASize, BSize, CSize};
    int* sizes[3] = {&sizes_array[0], &sizes_array[1], &sizes_array[2]};

    hanotaRecursive(ASize, A, B, C, sizes, capacities);
}

Answer 1

以下回复参考：皆我百晓生、券券喵儿等免费微信小程序作答:

你的问题是关于如何用C语言解决汉诺塔问题，并且遇到了“heap-buffer-overflow”的错误。这个错误通常发生在访问数组或字符串时超出了其分配的内存范围。在解决汉诺塔问题时，我们需要使用栈的概念来存储和操作盘子。下面是一个可能的解决方案：

首先，我们需要定义一些数据结构来存储盘子和执行移动操作。我们可以使用数组来模拟栈，并使用一些变量来跟踪每个栈的状态。以下是一个可能的实现：

#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 15  // 假设最大的盘子数量为14，加一个空位

void move(int n, char from, char to, char via, int A[], int B[], int C[], int ASize, int BSize, int CSize) {
    if (n == 1) {
        if (ASize > 0 && CSize < MAX_SIZE - 1) {  // 检查是否有盘子可以移动
            CSize++;  // 将盘子从A移到C
            C[CSize] = A[ASize];  // 将盘子放入C栈顶
            ASize--;  // 从A移除盘子
        } else {
            printf("Error: Array size exceeded or trying to move from an empty stack.\n");
        }
    } else {
        move(n - 1, from, via, to, A, C, B, ASize, BSize + 1, CSize);  // 将n-1个盘子从A移到B（使用C作为辅助）
        move(1, from, to, via, A, B, C, ASize, BSize, CSize);  // 将剩下的一个盘子从A移到目标位置（即B或C）
        move(n - 1, via, to, from, C, B, A, CSize - 1, BSize, ASize + 1);  // 将n-1个盘子从辅助栈移到目标位置（即A或C）
    }
}

int main() {
    int A[] = { 2, 1, 0 };  // 盘子的初始状态（升序排列）
    int B[] = {};  // 用于存放中间结果或结果状态，用于避免数组覆盖问题（与原图相比添加这一行）
    int C[] = {};  // 同上
    int ASize = sizeof(A) / sizeof(A[0]);  // A栈的大小（即盘子的数量）
    int BSize = sizeof(B) / sizeof(B[0]);  // B栈的大小（初始化为空）
    int CSize = sizeof(C) / sizeof(C[0]);  // C栈的大小（初始化为空）
    move(ASize, 'A', 'C', 'B', A, B, C, ASize, BSize, CSize);  // 从A移动到C，使用B作为辅助栈进行移动操作
    return 0;
}

关于你的错误信息，“heap-buffer-overflow”，我推测可能是由于你尝试访问超出分配内存范围的数组导致的。检查你的代码并确保你在访问数组时没有超出其分配的内存范围。此外，确保你的数组大小足够大以容纳所有可能的盘子移动操作。在上面的代码中，我假设了最大的盘子数量为MAX_SIZE - 1（其中MAX_SIZE是一个常量，我设置为15）。你可能需要根据你的具体需求调整这个值。