LeetCode: 3Sum, 获取 AddressSanitizer:DEADLYSIGNAL 错误

Question

我在 Eclipse 中的 PC 上尝试了这个问题，它工作正常。但是，当我在LeetCode 中尝试它时它崩溃了，我不明白为什么。

我在 LeetCode 上收到错误 "AddressSanitizer:DEADLYSIGNAL"。而且我无法在网站上调试它，因为我没有高级帐户。

在问题中，我被要求找到解决方案：

给定一个由 n 个整数组成的数组 nums，在 nums 中是否存在元素 a、b、c 使得 a + b + c = 0？在数组中找到所有唯一的三元组，其总和为零。 请注意，解集不得包含重复的三元组。

这是我的代码：

 #include "common.h"


int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    /**
     * Return an array of arrays of size *returnSize.
     * The sizes of the arrays are returned as *returnColumnSizes array.
     * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
     */
    int ii;
    bubble_sort(nums, numsSize);
    int **arr = (int**) calloc(numsSize* 3, sizeof(int*));
//  for (ii = 0; ii < numsSize; ii++)
//      arr[ii] =  (int*) calloc(3, sizeof(int));
    *returnSize = 0;
    int i, low, high = 0;
    int sum = 0;
    int target = 0;

    for  (i = 0; nums[i] <= 0 && i < numsSize -2;) {
        low = i + 1;
        high = numsSize - 1;

        while ( low < high) {
            sum = nums[i] + nums[low] + nums[high];
            if (sum > target)
                high--;
            else if (sum < target)
                low++;
            else {
                *returnSize += 1;
                arr[*returnSize-1] = (int*)malloc(sizeof(int)*3);
                arr[*returnSize-1][0] = nums[i];
                arr[*returnSize-1][1] = nums[low];
                arr[*returnSize-1][2] = nums[high];
                do high--; while(nums[high] == nums[high+1] && low < high);
            }

        }
        do i++; while (nums[i]==nums[i-1] && i < numsSize-2);
    }

    return arr;
}

void run_3sum() {
    printf("\n ---------- Run 3Sum ----------- \n");
    int n = 8;
    int i = 0;
    int* returnSize = (int*) malloc(sizeof(int));
    int** returnColumnSizes = (int**) malloc(sizeof(int));;
    int **res;
    int arr[8] = {-10, 0, 10, 2, -2, 5, 3, -8};//{-2,0,1,2,-1,3};

    int *nums = (int*) calloc(n+4, sizeof(int));
    for (i = 0; i < n; i++) {
            *nums = arr[i];
            nums++;
        }
    nums = nums - i;
    res = threeSum(nums, n, returnSize, returnColumnSizes);
    printf("\n Results ---3sum ---\n");
    printf_3sum(res, *returnSize, 3);
}

Answer 1

您的实施中有几个问题。最重要的原因是，您没有在threeSum() 函数中初始化和使用int** returnColumnSizes。您必须初始化并将值设置为int** returnColumnSizes。如果不需要这个变量，那么 leetcode 不应该把它作为函数参数传递。我们先来了解returnColumnSizes的用途。先来了解一下threeSum的函数签名：

• 函数的返回类型是int**。意思是，这个函数将返回一个指针的指针（一个指针将指向一个数组的起始指针）。
• 参数int* nums表示输入数组。
• 参数int numsSize表示nums数组的大小。
• 参数int* returnSize表示返回指针指向的数组的大小。
• 参数int** returnColumnSizes表示返回指针的内部数组大小。

这是这个问题的输入和输出示例：

Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]

现在，注意输出。输出是一个数组数组（基本上是指针的指针）。现在，对于这个输出，returnSize 将是 2 和 returnColumnSizes 将是一个大小为 2 的数组，它将表示如下：

int** returnColumnSizes = [3, 3]

这表示返回指针的内部指针所指向的元素数。现在，由于您没有在 threeSum() 函数中设置此值，因此程序会引发此错误，因为它不确定它将从指针中读取多少数据。在这里我已经解决了这个问题：

int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    /**
     * Return an array of arrays of size *returnSize.
     * The sizes of the arrays are returned as *returnColumnSizes array.
     * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
     */
    int ii;
    bubble_sort(nums, numsSize);
    
    *returnSize=0;
    int **arr=(int**)malloc(sizeof(int*) * numsSize);
    *returnColumnSizes=(int*)malloc(sizeof(int) * numsSize);
    
    int i, low, high = 0;
    int sum = 0;
    int target = 0;

    for  (i = 0; nums[i] <= 0 && i < numsSize -2;) {
        low = i + 1;
        high = numsSize - 1;

        while ( low < high) {
            sum = nums[i] + nums[low] + nums[high];
            if (sum > target)
                high--;
            else if (sum < target)
                low++;
            else {
                (*returnColumnSizes)[*returnSize]=3;
                arr[*returnSize] = (int*)malloc(sizeof(int)*3);
                arr[*returnSize][0] = nums[i];
                arr[*returnSize][1] = nums[low];
                arr[*returnSize][2] = nums[high];
                (*returnSize) += 1;
                do high--; while(nums[high] == nums[high+1] && low < high);
            }
        }
        do i++; while (nums[i]==nums[i-1] && i < numsSize-2);
    }
    
    return arr;
}

您的解决方案中还有其他几个问题。例如int **arr的大小应该动态调整，否则会分配比需要更多的内存。处理此问题的一般做法是，您应该从较少数量的内存开始，如果需要，您可以通过每次加倍来增加此数组的大小。 Here你会发现写在C中的这个问题的更有效的解决方案。