leetcode两数求和

孤不冷cing

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

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #define MAX 100
   
4. int main(void)
   
5. {
   
6.         int target = 0;
   
7.         int *num = calloc(MAX, sizeof(int));
   
8.         int result1 = 0, result2 = 0;
   
9.         int *num_d = calloc(MAX, sizeof(int));
   
10.         int **num_p = calloc(MAX, sizeof(int *)); // 二元数组，脚标代表num_a中元素的值（正），内层，一个表示是否出现，一个表示其在num_a中的>脚标
    
11.         for (int i = 0; i < MAX; i++)
    
12.         {
    
13.                 num_p[i] = calloc(2, sizeof(int));
    
14.         }
    
15.         int **num_n = calloc(MAX, sizeof(int *)); // 二元数组，脚标代表num_a中元素的值（负），内层，一个表示是否出现，一个表示其在num_a中的>脚标
    
16.         for (int i = 0; i < MAX; i++)
    
17.         {
    
18.                 num_n[i] = calloc(2, sizeof(int));
    
19.         }
    
20.         scanf("nums = [");
    
21.         int i = 0;
    
22.         while(scanf("%d,", &num[i++]))
    
23.                 ;
    
24.         scanf("], target = %d", &target);
    
25.         // calculates the num, which each element need
    
26.         for (int i = 0; i < MAX; i++)
    
27.         {
    
28.                 num_d[i] = target - num[i];
    
29.         }
    
30.         for (int i = 0; i < MAX; i++)
    
31.         {
    
32.                 if (num[i] >= 0)
    
33.                 {
    
34.                         num_p[num[i]][0] = 1;
    
35.                         num_p[num[i]][1] = i;
    
36.                 }
    
37.                 else
    
38.                 {
    
39.                         num_n[(0 - num[i])][0] = 1;
    
40.                         num_n[(0 - num[i])][1] = i;
    
41.                 }
    
42.         }
    
43.         for (int i = 0; i < MAX; i++)
    
44.         {
    
45.                 if (num_d[i] >= 0)
    
46.                 {
    
47.                         if(num_p[num_d[i]][0] == 1 && i != num_p[num_d[i]][1])
    
48.                         {
    
49.                                 result1 = i;
    
50.                                 result2 = num_p[num_d[i]][1];
    
51.                                 break;
    
52.                         }
    
53.                 }
    
54.                 else
    
55.                 {
    
56.                         if(num_n[(0 - num_d[i])][0] == 1 && i != num_p[num_d[i]][1])
    
57.                         {
    
58.                                 result1 = i;
    
59.                                 result2 = num_n[(0 - num_d[i])][1];
    
60.                                 break;
    
61.                         }
    
62.                 }
    
63.         }
    
64.         if((result1 != result2) && ((num[result1] + num[result2]) == target))
    
65.                 printf("[%d, %d]\n", result1, result2);
    
66.         else
    
67.                 printf("no result meets the requirements.\n");
    
68.         free(num);
    
69.         free(num_d);
    
70.         for (int i = 0; i < MAX; i++)
    
71.                 free(num_p[i]);
    
72.         free(num_p);
    
73.         for (int i = 0; i < MAX; i++)
    
74.                 free(num_n[i]);
    
75.         free(num_n);
    
76.         return 0;
    
77. }

复制代码

我在leetcode中修改的如下

1. /**
   
2. * Note: The returned array must be malloced, assume caller calls free().
   
3. */
   
4. int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
   
5.     if ((returnSize = (int *)calloc(2, sizeof(int))) == NULL)
   
6.         exit(EXIT_FAILURE);
   
7.     int *nums_d;
   
8.     if ((nums_d = (int *)calloc(numsSize, sizeof(int))) == NULL)
   
9.         exit(EXIT_FAILURE);
   
10.     int **nums_p;
    
11.     if ((nums_p = (int **)calloc(numsSize, sizeof(int *))) == NULL)
    
12.         exit(EXIT_FAILURE); // 二元数组，脚标代表num_a中元素的值（正），内层，一个表示是否出现，一个表示其在num_a中的>脚标
    
13.     for (int i = 0; i < numsSize; i++)
    
14.     {
    
15.         if ((nums_p[i] = (int *)calloc(2, sizeof(int))) == NULL){
    
16.             printf("calloc failed.\n%d\n", i);
    
17.             exit(EXIT_FAILURE);
    
18.         }
    
19.     }
    
20.     int **nums_n;
    
21.     if ((nums_n = (int **)calloc(numsSize, sizeof(int *))) == NULL); // 二元数组，脚标代表num_a中元素的值（负），内层，一个表示是否出现，一个表示其在num_a中的>脚标
    
22.     for (int i = 0; i < numsSize; i++)
    
23.     {
    
24.         if ((nums_n[i] = (int *)calloc(2, sizeof(int))) == NULL){
    
25.             printf("calloc failed.\n%d\n", i);
    
26.             exit(EXIT_FAILURE);
    
27.         }   
    
28.     }
    
29. 
    
30.     // calculates the num, which each element need
    
31.     for (int i = 0; i < numsSize; i++)
    
32.     {
    
33.         nums_d[i] = target - nums[i];
    
34.     }
    
35. 
    
36.     for (int i = 0; i < numsSize; i++)
    
37.     {
    
38.         if (nums[i] >= 0)
    
39.         {
    
40.             nums_p[nums[i]][0] = 1;
    
41.             nums_p[nums[i]][1] = i;
    
42.         }
    
43.         else
    
44.         {
    
45.             nums_n[(0 - nums[i])][0] = 1;
    
46.             nums_n[(0 - nums[i])][1] = i;
    
47.         }
    
48.     }
    
49. 
    
50.     for (int i = 0; i < numsSize; i++)
    
51.     {
    
52.         if (nums_d[i] >= 0)
    
53.         {
    
54.             if(nums_p[nums_d[i]][0] == 1 && i != nums_p[nums_d[i]][1])
    
55.             {
    
56.                 returnSize[0] = i;
    
57.                 returnSize[1] = nums_p[nums_d[i]][1];
    
58.                 break;
    
59.             }
    
60.         }
    
61.         else
    
62.         {
    
63.             if(nums_n[(0 - nums_d[i])][0] == 1 && i != nums_p[nums_d[i]][1])
    
64.             {
    
65.                 returnSize[0] = i;
    
66.                 returnSize[1] = nums_n[(0 - nums_d[i])][1];
    
67.                 break;
    
68.             }
    
69.         }
    
70.     }
    
71. 
    
72.     free(nums_d);
    
73.     for (int i = 0; i < numsSize; i++)
    
74.         free(nums_p[i]);
    
75.     free(nums_p);
    
76.     for (int i = 0; i < numsSize; i++)
    
77.         free(nums_n[i]);
    
78.     free(nums_n);
    
79. 
    
80.     return returnSize;
    
81. }

复制代码

它一直在报 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` 来读取数据，但是你的输入格式不正确，导致无法正确读取数据。你可以通过手动解析字符串来获取数字数组和目标值。

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

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. #define MAX 100
   
5. 
   
6. int *twoSum(int *nums, int numsSize, int target, int *returnSize) {
   
7.     // 分配返回结果的内存空间
   
8.     int *result = (int *)malloc(2 * sizeof(int));
   
9.     if (result == NULL) {
   
10.         printf("Memory allocation failed.\n");
    
11.         exit(EXIT_FAILURE);
    
12.     }
    
13. 
    
14.     int num_d[MAX];   // 存放每个元素所需的差值
    
15.     int num_p[MAX][2];   // 存放正数元素和对应的出现情况和索引
    
16.     int num_n[MAX][2];   // 存放负数元素和对应的出现情况和索引
    
17. 
    
18.     // 初始化 num_d 数组
    
19.     for (int i = 0; i < numsSize; i++) {
    
20.         num_d[i] = target - nums[i];
    
21.     }
    
22. 
    
23.     // 初始化 num_p 和 num_n 数组
    
24.     for (int i = 0; i < MAX; i++) {
    
25.         num_p[i][0] = 0;
    
26.         num_p[i][1] = -1;
    
27.         num_n[i][0] = 0;
    
28.         num_n[i][1] = -1;
    
29.     }
    
30. 
    
31.     for (int i = 0; i < numsSize; i++) {
    
32.         if (nums[i] >= 0) {
    
33.             num_p[nums[i]][0] = 1;
    
34.             num_p[nums[i]][1] = i;
    
35.         } else {
    
36.             num_n[-nums[i]][0] = 1;
    
37.             num_n[-nums[i]][1] = i;
    
38.         }
    
39.     }
    
40. 
    
41.     // 查找符合要求的结果
    
42.     for (int i = 0; i < numsSize; i++) {
    
43.         int num_d_index = abs(num_d[i]);
    
44.         if (num_d[i] >= 0) {
    
45.             if (num_p[num_d_index][0] == 1 && i != num_p[num_d_index][1]) {
    
46.                 result[0] = i;
    
47.                 result[1] = num_p[num_d_index][1];
    
48.                 break;
    
49.             }
    
50.         } else {
    
51.             if (num_n[num_d_index][0] == 1 && i != num_n[num_d_index][1]) {
    
52.                 result[0] = i;
    
53.                 result[1] = num_n[num_d_index][1];
    
54.                 break;
    
55.             }
    
56.         }
    
57.     }
    
58. 
    
59.     *returnSize = 2;
    
60.     return result;
    
61. }
    
62. 
    
63. int main(void) {
    
64.     int nums[] = {2, 7, 11, 15};
    
65.     int numsSize = sizeof(nums) / sizeof(nums[0]);
    
66.     int target = 9;
    
67.     int returnSize = 0;
    
68.    
    
69.     int *result = twoSum(nums, numsSize, target, &returnSize);
    
70.     printf("[%d, %d]\n", result[0], result[1]);
    
71.    
    
72.     free(result);
    
73.     return 0;
    
74. }

复制代码

这里给出了一个简单的示例，对于你提到的 `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` 来说，你只需要为其分配一个指向整型指针的内存空间，而不是一个二维整型数组的内存空间。

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

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

复制代码

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

以上回复来自 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 小助理，如未能正确解答您的问题，请继续追问。