leetcode两数求和

孤不冷cing

第一次用leetcode，第一题就无法成功运行
我在gcc中写得如下，可以按照我设想的运行

#include <stdio.h>
#include <stdlib.h>
#define MAX 100
int main(void)
{
        int target = 0;
        int *num = calloc(MAX, sizeof(int));
        int result1 = 0, result2 = 0;
        int *num_d = calloc(MAX, sizeof(int));
        int **num_p = calloc(MAX, sizeof(int *)); // 二元数组，脚标代表num_a中元素的值（正），内层，一个表示是否出现，一个表示其在num_a中的>脚标
        for (int i = 0; i < MAX; i++)
        {
                num_p[i] = calloc(2, sizeof(int));
        }
        int **num_n = calloc(MAX, sizeof(int *)); // 二元数组，脚标代表num_a中元素的值（负），内层，一个表示是否出现，一个表示其在num_a中的>脚标
        for (int i = 0; i < MAX; i++)
        {
                num_n[i] = calloc(2, sizeof(int));
        }
        scanf("nums = [");
        int i = 0;
        while(scanf("%d,", &num[i++]))
                ;
        scanf("], target = %d", &target);
        // calculates the num, which each element need
        for (int i = 0; i < MAX; i++)
        {
                num_d[i] = target - num[i];
        }
        for (int i = 0; i < MAX; i++)
        {
                if (num[i] >= 0)
                {
                        num_p[num[i]][0] = 1;
                        num_p[num[i]][1] = i;
                }
                else
                {
                        num_n[(0 - num[i])][0] = 1;
                        num_n[(0 - num[i])][1] = i;
                }
        }
        for (int i = 0; i < MAX; i++)
        {
                if (num_d[i] >= 0)
                {
                        if(num_p[num_d[i]][0] == 1 && i != num_p[num_d[i]][1])
                        {
                                result1 = i;
                                result2 = num_p[num_d[i]][1];
                                break;
                        }
                }
                else
                {
                        if(num_n[(0 - num_d[i])][0] == 1 && i != num_p[num_d[i]][1])
                        {
                                result1 = i;
                                result2 = num_n[(0 - num_d[i])][1];
                                break;
                        }
                }
        }
        if((result1 != result2) && ((num[result1] + num[result2]) == target))
                printf("[%d, %d]\n", result1, result2);
        else
                printf("no result meets the requirements.\n");
        free(num);
        free(num_d);
        for (int i = 0; i < MAX; i++)
                free(num_p[i]);
        free(num_p);
        for (int i = 0; i < MAX; i++)
                free(num_n[i]);
        free(num_n);
        return 0;
}

我在leetcode中修改的如下

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    if ((returnSize = (int *)calloc(2, sizeof(int))) == NULL)
        exit(EXIT_FAILURE);
    int *nums_d;
    if ((nums_d = (int *)calloc(numsSize, sizeof(int))) == NULL)
        exit(EXIT_FAILURE);
    int **nums_p;
    if ((nums_p = (int **)calloc(numsSize, sizeof(int *))) == NULL)
        exit(EXIT_FAILURE); // 二元数组，脚标代表num_a中元素的值（正），内层，一个表示是否出现，一个表示其在num_a中的>脚标
    for (int i = 0; i < numsSize; i++)
    {
        if ((nums_p[i] = (int *)calloc(2, sizeof(int))) == NULL){
            printf("calloc failed.\n%d\n", i);
            exit(EXIT_FAILURE);
        }
    }
    int **nums_n;
    if ((nums_n = (int **)calloc(numsSize, sizeof(int *))) == NULL); // 二元数组，脚标代表num_a中元素的值（负），内层，一个表示是否出现，一个表示其在num_a中的>脚标
    for (int i = 0; i < numsSize; i++)
    {
        if ((nums_n[i] = (int *)calloc(2, sizeof(int))) == NULL){
            printf("calloc failed.\n%d\n", i);
            exit(EXIT_FAILURE);
        }    
    }

    // calculates the num, which each element need
    for (int i = 0; i < numsSize; i++)
    {
        nums_d[i] = target - nums[i];
    }

    for (int i = 0; i < numsSize; i++)
    {
        if (nums[i] >= 0)
        {
            nums_p[nums[i]][0] = 1;
            nums_p[nums[i]][1] = i;
        }
        else
        {
            nums_n[(0 - nums[i])][0] = 1;
            nums_n[(0 - nums[i])][1] = i;
        }
    }

    for (int i = 0; i < numsSize; i++)
    {
        if (nums_d[i] >= 0)
        {
            if(nums_p[nums_d[i]][0] == 1 && i != nums_p[nums_d[i]][1])
            {
                returnSize[0] = i;
                returnSize[1] = nums_p[nums_d[i]][1];
                break;
            }
        }
        else
        {
            if(nums_n[(0 - nums_d[i])][0] == 1 && i != nums_p[nums_d[i]][1])
            {
                returnSize[0] = i;
                returnSize[1] = nums_n[(0 - nums_d[i])][1];
                break;
            }
        }
    }

    free(nums_d);
    for (int i = 0; i < numsSize; i++)
        free(nums_p[i]);
    free(nums_p);
    for (int i = 0; i < numsSize; i++)
        free(nums_n[i]);
    free(nums_n);

    return returnSize;
}

它一直在报 ERROR29 ，网上说是 calloc 这类申请内存的函数使用有误，但是鄙人技拙，看了两小时没明白是哪里或者哪些地方导致了错误，请大佬帮帮忙

FishC

首先，你的代码中存在一些问题导致编译错误和内存错误。

1. 头文件引入问题：你需要包含 `<stdio.h>`、`<stdlib.h>` 这两个头文件来使用 `calloc`、`exit`、`printf` 和其他相关函数。

2. `num`、`num_d`、`num_p` 和 `num_n` 的类型问题：这些变量声明时应为整型数组，而不是指针。应该这样声明：`int num[MAX];`、`int num_d[MAX];`、`int num_p[MAX][2];`、`int num_n[MAX][2];`。

3. 内存申请问题：在申请内存时，你需要为每个数组元素分配内存，应该是 `num_p[i] = (int *)calloc(2, sizeof(int));` 和 `num_n[i] = (int *)calloc(2, sizeof(int));`。

4. 输入格式问题：你使用了 `scanf` 来读取数据，但是你的输入格式不正确，导致无法正确读取数据。你可以通过手动解析字符串来获取数字数组和目标值。

下面是修复后的代码示例：

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

#define MAX 100

int *twoSum(int *nums, int numsSize, int target, int *returnSize) {
    // 分配返回结果的内存空间
    int *result = (int *)malloc(2 * sizeof(int));
    if (result == NULL) {
        printf("Memory allocation failed.\n");
        exit(EXIT_FAILURE);
    }

    int num_d[MAX];   // 存放每个元素所需的差值
    int num_p[MAX][2];   // 存放正数元素和对应的出现情况和索引
    int num_n[MAX][2];   // 存放负数元素和对应的出现情况和索引

    // 初始化 num_d 数组
    for (int i = 0; i < numsSize; i++) {
        num_d[i] = target - nums[i];
    }

    // 初始化 num_p 和 num_n 数组
    for (int i = 0; i < MAX; i++) {
        num_p[i][0] = 0;
        num_p[i][1] = -1;
        num_n[i][0] = 0;
        num_n[i][1] = -1;
    }

    for (int i = 0; i < numsSize; i++) {
        if (nums[i] >= 0) {
            num_p[nums[i]][0] = 1;
            num_p[nums[i]][1] = i;
        } else {
            num_n[-nums[i]][0] = 1;
            num_n[-nums[i]][1] = i;
        }
    }

    // 查找符合要求的结果
    for (int i = 0; i < numsSize; i++) {
        int num_d_index = abs(num_d[i]);
        if (num_d[i] >= 0) {
            if (num_p[num_d_index][0] == 1 && i != num_p[num_d_index][1]) {
                result[0] = i;
                result[1] = num_p[num_d_index][1];
                break;
            }
        } else {
            if (num_n[num_d_index][0] == 1 && i != num_n[num_d_index][1]) {
                result[0] = i;
                result[1] = num_n[num_d_index][1];
                break;
            }
        }
    }

    *returnSize = 2;
    return result;
}

int main(void) {
    int nums[] = {2, 7, 11, 15};
    int numsSize = sizeof(nums) / sizeof(nums[0]);
    int target = 9;
    int returnSize = 0;
    
    int *result = twoSum(nums, numsSize, target, &returnSize);
    printf("[%d, %d]\n", result[0], result[1]);
    
    free(result);
    return 0;
}

这里给出了一个简单的示例，对于你提到的 `leetcode` 问题，你可以根据实际需求进行修改。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

孤不冷cing

FishC 发表于 2024-3-9 15:50
首先，你的代码中存在一些问题导致编译错误和内存错误。

1. 头文件引入问题：你需要包含 ``、`` 这两个 ...

我直接用指针变量，然后为指针变量申请内存，不也是等效于数组吗？我没明白

FishC

孤不冷cing 发表于 2024-03-09 15:52
我直接用指针变量，然后为指针变量申请内存，不也是等 ...

对于数组来说，你可以通过指针来访问数组元素，因为数组名本身就是指向数组首元素的指针。所以，你可以使用指针变量来代替数组进行计算。

在你的代码中，你使用了 `calloc` 函数为指针变量申请内存，这是合理的。但是在你申请内存的方式上存在问题。在你的示例代码中，你声明了 `int *num`、`int *num_d`、`int **num_p`、`int **num_n` 这样的指针变量，然后用 `calloc` 为每个指针变量分配了内存。但实际上，你应该为指针变量分配内存时，需要根据指针变量的类型来确定所需内存空间的大小。

当你使用 `int *num` 声明一个指向整型的指针时，你只需要为其分配一个整型数据的内存空间，而不是一个整型数组的内存空间。同理，对于二维指针变量 `int **num_p` 和 `int **num_n` 来说，你只需要为其分配一个指向整型指针的内存空间，而不是一个二维整型数组的内存空间。

在内存申请方面，你可以按照下面的方式修改你的代码：

int *num = calloc(MAX, sizeof(int));  // 申请整型数组的内存空间
int *num_d = calloc(MAX, sizeof(int));  // 申请整型数组的内存空间
int **num_p = calloc(MAX, sizeof(int *));  // 申请指向整型指针的内存空间
for (int i = 0; i < MAX; i++) {
    num_p[i] = calloc(2, sizeof(int));  // 为每个指针变量分配内存空间
}
int **num_n = calloc(MAX, sizeof(int *));  // 申请指向整型指针的内存空间
for (int i = 0; i < MAX; i++) {
    num_n[i] = calloc(2, sizeof(int));  // 为每个指针变量分配内存空间
}

这样，你就可以正确地为指针变量申请内存，并且使用指针变量来代替数组进行计算。希望能够解答你的疑问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

孤不冷cing

FishC 发表于 2024-3-9 15:52
对于数组来说，你可以通过指针来访问数组元素，因为数组名本身就是指向数组首元素的指针。所以，你可以 ...

你说的没错，但是我不认同

FishC

孤不冷cing 发表于 2024-03-09 15:58
你说的没错，但是我不认同

很抱歉，我的回答没有达到你的期望。作为一个计算机教育专家，我的目标是以通俗易懂的方式解释问题，并提供可行的解决方案。

确实，在某些情况下，指针变量可以被视为数组来使用。指针可以指向内存中的一块连续空间，从而模拟数组的行为。你可以通过指针算术运算来访问和操作指针所指向的连续内存区域。

然而，在你的代码中，你对指针的使用可能存在一些问题。你使用 `calloc` 函数为指针变量分配内存空间时，注意要根据指针所指向的数据类型来确定需要分配的内存大小。此外，你还需要考虑内存释放的问题，避免内存泄漏。

如果你有其他意见或疑问，欢迎继续讨论。我将尽力提供帮助。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

孤不冷cing

噢，我知道错在哪里了。。。
我的 nums_p 和 nums_n 的元素数，应该始终确保比 nums 中最大的数多，否则就会造成越界。
我一直以为是我对指针和数组的理解有误，在用指针代替数组时出现了什么语法错误，没注意到就是单纯的越界。。。

FishC

孤不冷cing 发表于 2024-03-09 16:44
噢，我知道错在哪里了。。。
我的 nums_p 和 nums_n  ...

没问题，你已经找到了问题的所在！确保为 `nums_p` 和 `nums_n` 分配足够的内存空间以容纳 `nums` 中的最大元素是非常重要的。这样可以避免越界访问的问题。当我们使用指针来模拟数组时，确保分配足够的内存空间是非常关键的。感谢你的反思和发现问题的能力！如果还有其他问题需要解决，随时告诉我，我将尽力帮助你。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

孤不冷cing

@不二如是 我无法将自己的回答作为最佳答案，但是我已经知道了自己的错误所在，能帮我把帖子设置成已解决状态吗

FishC

孤不冷cing 发表于 2024-03-09 16:47
@不二如是 我无法将自己的回答作为最佳答案，但是我已 ...

非常抱歉，作为AI助手，我无法直接更改帖子的状态或标记为已解决。你可以联系管理员或在论坛中提出请求，让他们将帖子标记为已解决。祝你在将来的学习和编程过程中取得更多的进展！如果你还有其他问题，随时向我提问。我会尽力帮助你。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。