C语言好题分享七（三数之和）

❀❀❀ 文章由@不准备秃的大伟原创 ❀❀❀

♪♪♪ 若有转载，请联系博主哦~ ♪♪♪

❤❤❤ 致力学好编程的宝藏博主，代码兴国！❤❤❤

三数之和

题目来源LeetCode：刷题传送门

题目：给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。

请你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

由题目可以得到我们呢需要求的是一个数组内的三个和为0的元素，且需要是不同的三个元素。

其实当我们进去做题目的时候会发现提干处会有如下一段英文

/*

* 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().

*/

简单翻译一下就是：

返回一个大小为 *returnSize 的数组，数组中的每个元素都是一个数组。

数组的大小作为 *returnColumnSizes 数组返回。

注意：返回的数组和 *columnSizes 数组都必须使用 malloc 进行分配内存，假设调用者会调用 free() 进行释放。

在C语言中我们不仅要实现代码，还需要考虑*returnSize和*returnColumnSize的开辟，这一点其实是在做题时C比其他语言要繁琐的地方

算法一：暴力求解

同样的我们先来最简单也最容易想到的暴力求解：使用三个for循环一个一个找：（伪代码实现）

//由于这段代码有很多的细节没有考虑，所以暂时就先不管returnSize和returnColumnSize的开辟了
int** ans = malloc(sizeof(int*)*numsSize)
for(int i = 0; i < numsSize - 2; i++){
    for(int j = i + 1; j < numsSize - 1; j++){
        for(int k = numsSize - 1; k > 1; k--){
ans[*returnSize][0] =nums[i];//ans为一个二维数组
ans[*returnSize][1] =nums[j];
ans[*returnSize][2] =nums[k];
(*returnSize++);
//如果满足ans[i] + ans[j] + ans[k] == 0 则存入ans里
}
}
}
return ans;

这一种方法很笨，但是也很容易想到，时间复杂度是O(N*N*N)。

那我们来想一想这一段代码除了没有考虑returnSize的returnColumnSize的开辟，其他有没有什么别的问题？

是的，聪明且细心的铁汁一定发现了，题目要求：不同的三元组，所以我们还需要写一段代码判断是否有重复的答案存在。

好的，到这里铁汁们是不是头都要秃了啊？○( ＾皿＾)っHiahiahia… 那这样，我们先来看一条类似的但更简单的题目：

两数之和

题目来源LeetCode：刷题传送门

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

/**

* Note: The returned array must be malloced, assume caller calls free().

*/

返回的答案必须使用 malloc 进行分配内存，假设调用者会调用 free() 进行释放。

思想一：暴力求解

太简单了，所以博主直接放代码了：

int* twoSum(int* nums, int numsSize, int target, int* returnSize)
{
   for(int i = 0; i < numsSize; i++)
   {
       for(int j = i + 1; j < numsSize; j++)
       {
           if(nums[i] + nums[j] == target)
           {
          *returnSize = 2;
                int* ans = (int*)malloc(sizeof(int) * 2);
                ans[0] = i; ans[1] = j; 
                return ans;
           }
       }
   } 
   *returnSize = 0;
   return NULL;
}

思想二：排序+双指针

看过博主上一篇好题分享的铁汁们应该对双指针有所了解了，其实在熟练掌握了排序+双指针之后像这种类似的题目的第一个想法就应该是双指针了。

两数之和比三数之和简单的原因不仅是数字变少了，而且最终的答案也只有一组解，不需要考虑去重，需要开辟的空间内容也少了。

不知道铁汁们还记不记得上一次的双指针思路了，不记得的话....：--->盛水最多的容器

好的，我们大概回顾一下哈~：我们所谓的双指针呢，不是真的指针，而是用两个数来表示数组的下标，一般一个指向第一个元素，一个指向最后一个元素，在不同的情况下对两个数进行不同的操作。

嗯...怎么说呢，这道题想到双指针本身是很好的想法，但是我们答案需要我们返回的是元素下标，所以如果我们使用qsort排序后，下标就会被打乱，这样返回的答案就会有错误。那如果我们改一下，最后的答案求的是两个值，那么双指针就是嘎嘎棒了！

虽然求两个数的和我们不可以用双指针，但是我们可以把思维套用到求三个数的和的那个题目上：

三数之和の思想二：排序+双指针

首先我们先把nums排个序，因为我们的方法是以排序为起点的嘛：

 int cmp(const int* p1,const int* p2)
 {
     return *p1 - *p2;
 }
//函数内
qsort(nums,numsSize,sizeof(int),cmp);

首先我们先实现代码的主体：不管怎么说，实现题目的需求才是第一重要嘛：

int j = 0;//这里引用一个变量j，表示的答案有多少个，即returnSize，所以只要最后=一下就可以了 
int left = 0;
    int right = i - 1;
    while(left < right)
    {
        if(nums[left] + nums[right] + nums[i] == 0) {
         ans[j] = (int*)malloc(sizeof(int) * 3);
        ans[j][0] = nums[left];
        ans[j][1] = nums[right];
        ans[j][2] = nums[i];
        j++;
        left++;
        right--;
    }
        else if(nums[left] + nums[right] + nums[i] > 0)
        right--;
        else
        left++;

好，上面我们已经实现了主体，接下来我们需要考虑*reuturnSize和*returnColumnSize 内存的开辟：但是~先别急，我们在写答案的时候如果没有可以返回的答案能行吗？当然不行了啊，所以呢，在考虑其他细节之前，我们要把答案存到一个二维数组里面啊!

    int** ans = malloc(sizeof(int*)*numsSize*numsSize);
//行
    ans[j][0] = nums[left];
    ans[j][1] = nums[right];
    ans[j][2] = nums[i];
//三列，在暴力求解里已经写过了

这时候会有铁汁问了：“博主啊，你这个**ans为什么开辟了个numsSize*numsSize*sizeof(int) 大小的空间啊？” ，问得好，其实我们可以想象一下：

三个数和为0，当其中一个数变化，其他一个或者两个数肯定会变化的，而我们考虑最坏的情况，每次三个数只动两个数就可以满足和为0，那这是不是就类似两个变量的循环，复杂度为O(N*N)，最后不也就是numsSize*numsSize*sizeof(int) ？

但我们毕竟不能准确的计算需要的空间，开辟的大一点以防止越界。

接下来我们考虑*reuturnSize和*returnColumnSize 内存的开辟：由函数主体可以得到j就是*returnSize，所以不知不觉中我们就把他的值给算出来了，而*returnColumnSize就比较麻烦了：

*returnColumnSizes = (int*)malloc(numsSize * numsSize *sizeof(int));
//行（同样的，开辟大一点没什么不好）
(*returnColumnSizes)[j] = 3;
//列（可以直接放在while循环内，每一行就是3个元素）
*returnSize = j;

这时候我们的代码就基本写好了，然后会有铁汁迫不及待的点个提交，然后“啪”的一下显示个错误，然后又回来骂博主了：“你这教的啥，都错的！”

诶诶诶，别啥事都赖我啊o(TヘTo) ，还亏我在文章开头夸你呢！现在我又得骂你记性不好了！ (┬＿┬)↘

忘了吧？是不是忘了？忘了去重了吧？！

其实实现去重也是比较简单的：

但是又有一个问题了：如果我们的案例是{0,0,0,0}的话不就会越界吗？所以我们还需要加个判断条件，代码实现如下：

while(left < right && nums[left] == nums[left + 1]) left++;
        while(right > left && nums[right] == nums[right - 1]) right--;
//千万记住left < right要放在==前面，因为&&的短路性质，当前面条件不成立的时候，就不会判断后面的条件，所以也就不会报错

最后我们只需要return ans;就可以完成我们的代码了，展示一下自己的成果吧：

int cmp(const int* p1,const int* p2)
 {
     return *p1 - *p2;
 }
int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
    qsort(nums,numsSize,sizeof(int),cmp);
    int** ans = malloc(sizeof(int*)*numsSize*numsSize);
    *returnColumnSizes = (int*)malloc(numsSize * numsSize *sizeof(int));
    int j = 0;
for(int i = numsSize - 1; i > 1; i--)
{
    if(i < numsSize -1 && nums[i] == nums[i + 1]) continue;
        int left = 0;
    int right = i - 1;
    while(left < right)
    {
        if(nums[left] + nums[right] + nums[i] == 0) {
         (*returnColumnSizes)[j] = 3;
         ans[j] = (int*)malloc(sizeof(int) * 3);
        ans[j][0] = nums[left];
        ans[j][1] = nums[right];
        ans[j][2] = nums[i];
        j++;
                while(left < right && nums[left] == nums[left + 1]) left++;
        while(right > left && nums[right] == nums[right - 1]) right--;
        left++;
        right--;
        }
        else if(nums[left] + nums[right] + nums[i] > 0)
        right--;
        else
        left++;
    }
}
*returnSize = j;
return ans;

}

然后提交，通过！