[已解决]关于c语言中两个数组的普通的加法问题

kaishao

如图所示，为什么一直返回的是空数组啊

网址：https://leetcode.cn/problems/two-sum/submissions/

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.     int a,b,c[2];
   
6.     for (a = 0;a<numsSize;a++){
   
7.         for(b=0;b<numsSize;b++){
   
8.             if (target == nums[a] + nums[b]){
   
9.                 c[0] = a;
   
10.                 c[1] = b;
    
11.                 return c;
    
12.             
    
13.             }
    
14.         }
    
15.     }
    
16.     return 0;
    
17. }
    
18. 
    
19. 
    

复制代码

最佳答案

月排行榜 / 总排行榜

python/print

2023-7-7 13:50:59

使用动态分配内存：

1. int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
   
2.     int a, b;
   
3.     int* c = (int*)malloc(2 * sizeof(int));
   
4.   
   
5.     for (a = 0; a < numsSize; a++) {
   
6.         for (b = 0; b < numsSize; b++) {
   
7.             if (target == nums[a] + nums[b]) {
   
8.                 c[0] = a;
   
9.                 c[1] = b;
   
10.                 *returnSize = 2;
    
11.                 return c;
    
12.             }
    
13.         }
    
14.     }
    
15.   
    
16.     *returnSize = 0;
    
17.     return NULL;
    
18. }

复制代码

使用静态数组：

1. int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
   
2.     int a, b;
   
3.     static int c[2];
   
4.    
   
5.     for (a = 0; a < numsSize; a++) {
   
6.         for (b = 0; b < numsSize; b++) {
   
7.             if (target == nums[a] + nums[b]) {
   
8.                 c[0] = a;
   
9.                 c[1] = b;
   
10.                 *returnSize = 2;
    
11.                 return c;
    
12.             }
    
13.         }
    
14.     }
    
15.   
    
16.     *returnSize = 0;
    
17.     return NULL;
    
18. }

复制代码

这两种版本的修改都会返回一个包含两个索引的整数数组，表示满足条件的两个数在原始数组中的位置。当没有找到符合条件的数对时，返回空指针，并将`returnSize`设置为0。

跳转到最佳答案楼层

isdkz

这段代码的问题在于返回的是一个局部数组c的地址，而不是动态分配的内存空间。当函数结束后，局部数组c将被销毁，所以返回的地址将变得无效。

解决这个问题的方法是使用动态分配内存的方式来创建一个新的数组，并将结果存储在其中。修改代码如下：

1. int* twoSum(int* nums, int numsSize, int target, int* returnSize){
2.     int a, b;
3.     int* c = malloc(2 * sizeof(int)); // 动态分配内存空间
4.     for (a = 0; a < numsSize; a++){
5.         for(b = 0; b < numsSize; b++){
6.             if (target == nums[a] + nums[b]){
7.                 c[0] = a;
8.                 c[1] = b;
9.                 *returnSize = 2; // 设置返回数组的大小
10.                 return c;
11.             }
12.         }
13.     }
14.     return NULL;
15. }

复制代码

在这个修改后的代码中，我们使用 malloc 函数动态分配了一个大小为2的整型数组，并将结果存储在其中。我们还通过 returnSize 参数将返回数组的大小传递给调用者。

陶远航

根据你提供的代码，有几个问题可能导致返回空数组：

返回类型错误：你的函数声明中指定了返回类型为 int*，这表示函数应该返回一个整数数组的指针。然而，在代码中，当找到目标和时，你直接返回了一个整数数组 c。这在编译时可能会导致类型不匹配的错误。你需要使用 malloc 分配内存来创建一个整数数组，并返回该数组的指针。调用者负责在使用完数组后调用 free 来释放内存。

数组越界：在你的代码中，你使用两个嵌套循环来遍历数组 nums 中的所有可能的组合。然而，在内部循环中，你的索引变量是 b，它可能会超出数组 nums 的有效索引范围。你应该将内部循环的起始条件改为 b = a + 1，这样可以避免重复计算相同的元素组合。

以下是经过修正的代码：

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.     int a, b, *result;
   
6.     result = (int*)malloc(2 * sizeof(int)); // 分配存储结果的数组内存空间
   
7. 
   
8.     for (a = 0; a < numsSize; a++){
   
9.         for (b = a + 1; b < numsSize; b++){
   
10.             if (target == nums[a] + nums[b]){
    
11.                 result[0] = a;
    
12.                 result[1] = b;
    
13.                 *returnSize = 2; // 更新返回数组的大小
    
14.                 return result;
    
15.             }
    
16.         }
    
17.     }
    
18. 
    
19.     *returnSize = 0; // 如果没有找到满足条件的组合，将返回数组大小设为 0
    
20.     return NULL;
    
21. }

复制代码

请注意，以上修正的代码假设调用者会在使用完返回的数组后调用 free 来释放内存，以避免内存泄漏。另外，你需要将调用 twoSum 函数的地方更新为使用返回数组的指针和大小，以便正确处理结果。

不二如是

鱼油代码中有几点可以改进:

• 使用散列表(hash table)可以加速查找速度。我们可以构建一个散列表, key 为数组的值,value 为数组索引。这样,查找 target - x 的值的时间复杂度为 O(1)。
• 直接返回散列表中的索引,不需要构建中间数组 c。 这可以减少内存使用和复制开销。
• 需要注意边界条件,比如数组中有重复元素的情况。
  

改进后的代码如下:

1. int* twoSum(int* nums, int numsSize, int target, int* returnSize){
   
2.     *returnSize = 2;
   
3.     int *result = malloc(2 * sizeof(int));
   
4.    
   
5.     // 构建散列表
   
6.     int *hashTable = malloc(numsSize * sizeof(int));
   
7.     memset(hashTable, -1, numsSize * sizeof(int));
   
8.    
   
9.     for (int i = 0; i < numsSize; i++) {
   
10.         int complement = target - nums[i];
    
11.         if (hashTable[complement] != -1) {
    
12.             result[0] = hashTable[complement];
    
13.             result[1] = i;
    
14.             return result;
    
15.         }
    
16.         hashTable[nums[i]] = i;
    
17.     }
    
18. }

复制代码

歌者文明清理员

不二如是 发表于 2023-7-6 22:26
鱼油代码中有几点可以改进:

?！是不是gpt？

涛4091

证明我是一个人类

python/print

使用动态分配内存：

1. int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
   
2.     int a, b;
   
3.     int* c = (int*)malloc(2 * sizeof(int));
   
4.   
   
5.     for (a = 0; a < numsSize; a++) {
   
6.         for (b = 0; b < numsSize; b++) {
   
7.             if (target == nums[a] + nums[b]) {
   
8.                 c[0] = a;
   
9.                 c[1] = b;
   
10.                 *returnSize = 2;
    
11.                 return c;
    
12.             }
    
13.         }
    
14.     }
    
15.   
    
16.     *returnSize = 0;
    
17.     return NULL;
    
18. }

复制代码

使用静态数组：

1. int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
   
2.     int a, b;
   
3.     static int c[2];
   
4.    
   
5.     for (a = 0; a < numsSize; a++) {
   
6.         for (b = 0; b < numsSize; b++) {
   
7.             if (target == nums[a] + nums[b]) {
   
8.                 c[0] = a;
   
9.                 c[1] = b;
   
10.                 *returnSize = 2;
    
11.                 return c;
    
12.             }
    
13.         }
    
14.     }
    
15.   
    
16.     *returnSize = 0;
    
17.     return NULL;
    
18. }

复制代码

这两种版本的修改都会返回一个包含两个索引的整数数组，表示满足条件的两个数在原始数组中的位置。当没有找到符合条件的数对时，返回空指针，并将`returnSize`设置为0。