《力扣题库（C）：第15题 （三数之和）》

第十五题：三数之和

• 给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
• 注意：答案中不可以包含重复的三元组。

 

示例 1：

• 输入：nums = [-1,0,1,2,-1,-4]
• 输出：[[-1,-1,2],[-1,0,1]]

示例 2：

• 输入：nums = []
• 输出：[]

示例 3：

• 输入：nums = [0]
• 输出：[]

提示：

• 0 <= nums.length <= 3000
• -105 <= nums[i] <= 105

解题：

/**
 * @file 15.cpp
 * @author HarkerYX
 * @brief  三数之和
 * @version 0.1
 * @date 2021-04-30
 * 
 * @copyright Copyright (c) 2021
 * 
 */


/*
第十五题：三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。

解题思路:

*/

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



void printfNums(int **p,int size)
{
    printf("[\n");

    for (int i = 0; i < size;i++)
    {
        int *tmp = (int *)p[i];
        
        printf("[");
        for (int j = 0; j < 3; j++)
            printf("%d,",tmp[j]);
    
         printf("]\n");

    }

    printf("]\n");
}

/**
 * @brief 
 * 
 * @param nums 
 * @param numsSize 
 * @param returnSize 
 * @param returnColumnSizes 
 * @return int** 
 */


/*  不去重

// 如果不去重直接循环得到就行，关键在于要去重，如果把数据得到再去重就很麻烦

int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){

    // 这里要算出最大能有多少组 例如5个取3个就是组合 C53 = 5!/3*2*1 = 20个 就是 
    // 但是 numsSize 也不固定，具体分多大可以细算下，为了方便就分 numsSize*numsSize
    returnColumnSizes = (int **)malloc(numsSize * numsSize * sizeof(int));

    for (int i = 0; i < numsSize-2;i++)
    {
        for (int j = i + 1; j < numsSize-1; j++)
        {
            for (int k = j + 1; k < numsSize; k++)
            {
                if (nums[i] + nums[j] + nums[k] == 0)
                {
                    printf("%d,%d,%d\n",nums[i],nums[j],nums[k]);
                    
                    //动态创建数组
                    int *tmp = (int *)malloc(sizeof(int) * 3);
                    tmp[0] = nums[i];
                    tmp[1] = nums[j];
                    tmp[2] = nums[k];

                    returnColumnSizes[*returnSize] = tmp;
                    *returnSize+=1;
          
                }
            }
        }
    }

    printf("returnSize = %d\n", *returnSize);

    return returnColumnSizes;
}

*/

// 去重
// 第一步先排序
// 第二步排序基础上再进行判断，可以跳过重复


//冒泡排序
void BubbleSort(int* nums,int size)
{
    int *p = nums;

    for (int i = 0; i< size;i++)
    {
        for(int j=i+1; j< size;j++)
        {
            if(p[j]< p[i])
            {
                int tmp = p[i];
                p[i] = p[j];
                p[j] = tmp;
            }
        }
    }

}

int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){

    int sum = 0;
    // 这里要算出最大能有多少组 例如5个取3个就是组合 C53 = 5!/3*2*1 = 20个 就是 
    // 但是 numsSize 也不固定，具体分多大可以细算下，为了方便就分 numsSize*numsSize
    returnColumnSizes = (int **)malloc(numsSize * numsSize * sizeof(int));

    for (int i = 0; i < numsSize-1; i++)
    {
        //最左边都大于0了没必要判断了，因为是排过序的 从小到大
        if(nums[i]>0)
            break;

        //判断第一个数是不是和之前一样，如果一样继续往后走,第一个不用判断
        if(i>0 && nums[i] == nums[i-1])
            continue;

        int left = i + 1;
        int right = numsSize - 1;
        //判断条件是第二个和第三个不相等，left代表第二个在第一个数的后面， right代表第三个在整个数组的最右边
        while(left < right){

            sum = nums[i] + nums[left] + nums[right];
            if(sum==0){

                //动态创建数组
                int *tmp = (int *)malloc(sizeof(int) * 3);
                tmp[0] = nums[i];
                tmp[1] = nums[left];
                tmp[2] = nums[right];

                returnColumnSizes[*returnSize] = tmp;
                *returnSize+=1;

                //                                   *  *                     *
                //                                   ^                 ^  ^
                //当等于0找到时候，这里进行去重，好比 [-3,-1,-1,-1,-1,-1,0,1,1,4,4]
                //当 *时候等于0，然后左判断后面是否一样，右判断前面是否一样，如果一样就移动去掉重复

                while(left < right && nums[left] == nums[++left]);
                while (left < right && nums[right] == nums[--right]);
            }
            else if(sum <0) // 判断左右两个指针如何移动，小于说明要加大，左边往前
                left++;
            else
                right--;

        }
    }

    printf("returnSize = %d\n", *returnSize);

    return returnColumnSizes;
}

int main(void)
{
    // int nums[] = {-1, 0, 1, 2, -1, -4};

    int nums[] = {-3, 3 ,5, -5 ,-1, 0, 1, 2, -1, -4};
    int retSize = 0;
    int **ret = NULL;

    if(sizeof(nums)/sizeof(int) <3)
        return -1;

    // 排序
    BubbleSort(nums,sizeof(nums)/sizeof(int));

    // 计算
    ret = threeSum(nums,sizeof(nums)/sizeof(int),&retSize,ret);

    printfNums(ret,retSize);
    return 0;
}

D:\Working\myleetcode\C>.\15
returnSize = 8
[
[-5,0,5,]
[-5,2,3,]
[-4,-1,5,]
[-4,1,3,]
[-3,0,3,]
[-3,1,2,]
[-1,-1,2,]
[-1,0,1,]
]