leetcode 15 3Sum

最新推荐文章于 2020-12-27 09:28:24 发布
最新推荐文章于 2020-12-27 09:28:24 发布
阅读量228 收藏
点赞数
分类专栏： leetcode 文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/javays1/article/details/48026483
版权

3Sum
Total Accepted: 70783 Total Submissions: 419673

Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

Note:

Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ≤ b ≤ c)
The solution set must not contain duplicate triplets.

For example, given array S = {-1 0 1 2 -1 -4},

A solution set is:
(-1, 0, 1)
(-1, -1, 2)

这道题是之前的第一题2Sum的升级版，除了要求找出所有可能的符合的3元组之外，还要以非降序输出。下面就结合代码来解释：

int** threeSum(int* nums, int numsSize, int* returnSize)
{
    if(numsSize == 0)
        return NULL;
    int min_element = 100000000;
    int max_element = -100000000;
    for(int i = 0; i < numsSize; i++)
    {
        if(min_element > nums[i])
            min_element = nums[i];
        if(max_element < nums[i])
            max_element = nums[i];
    }

    int offset = -1* min_element;

函数一开始先判断是空的情况，如果是空则返回NULL。然后找出整个输入数据中的最大值和最小值，这样的目的是为了确定hash表的长度以及偏移量offset的值。偏移量等于最小元素值的相反数，这样的目的是为了通过offset使得min_element对应于hash表的第一个位置。

    int *hashTable = (int*)malloc(sizeof(int)*(max_element - min_element + 1));

    memset(hashTable, 0, sizeof(int) * (max_element - min_element + 1));
    for(int i = 0; i < numsSize; i++)
    {
        hashTable[nums[i] + offset]++;
    }

确定了大小，下一步就是生成这张hash表，然后用memset函数把hash表全部置为0，然后循环为每个输入的数找到对应的hash表的位置，然后将对应的hash表的值加1.

    int **result = (int**)malloc(sizeof(int*) * 300);
    *returnSize = 0;
    for(int i = 0; i < numsSize; i++)
    {
        int target = -1 * nums[i];
        int *newHashTable = (int*)malloc(sizeof(int) * (max_element - min_element + 1));
        memcpy(newHashTable, hashTable, sizeof(int) * (max_element - min_element + 1));
        if(newHashTable[nums[i] + offset] > 0)
            newHashTable[nums[i] + offset]--;
        else if(newHashTable[nums[i] + offset] == 0)
            continue;
        twoSum(nums, numsSize, returnSize, newHashTable, max_element - min_element + 1, target, i+1, offset, result, nums[i]);
        hashTable[nums[i] + offset] = 0;

    }

    return result;
}

首先开一个存储结果的二维数组，这个地方我设的值是300，也就是说最多支持300种三维组，当然如果册数数据很大，那么很可能结果会多于300种，但就这道题而言300够用了。然后我们进入到循环之中，按顺序取数组中每一个数，由于要求相加的结果为0，所以我们的目标target就是剩下的两个数的相加之和是第一个数的相反数，然我们复制当前的hash表，原因是在每次进入twoSum之前，hash表都会做特定的修改，而这个修改只在这一次迭代中起作用，下次迭代时我们可能并不需要这个修改，要使用原本的hash表。因此每次迭代我们都将原本的hash表复制一张，然后然后复制的hash表仅用于这一次的迭代。

产生了新的hash表之后，我们当前的这个值在hash表中的值，如果大于0，说明这个值存在于输入中，因此我们使用了当前值之后，当前值对应的数量就会减少1. 如果当前值对应的hash表中的值为0，说明这个值已经不能再使用了（有可能是当前值出现了多次，之前已经使用过当前值作第一个值了，所有可能的组合都找出来了），所以直接跳过进入下一次的迭代。

之后我们就可以进入twoSum函数，即找出两个值，它们之和为target，当twoSum函数返回后，把当前值置为0，因为所有使用当前值作为第一个值得情况我们已经都找出来了，如果之后又碰到当前值做第一个值，那我们就可以直接跳过了。

void twoSum(int* nums, int numsSize, int* returnSize, int *hashTable, int hTlen, int target, int start, int offset, int**result, int current)
{
    int NeedValue;

    int count = *returnSize;
    for(int i = start; i < numsSize; i++)
    {
        if(!hashTable[nums[i]+offset])
            continue;
        hashTable[nums[i]+offset]--;
        NeedValue = target - nums[i];
        if(NeedValue + offset < 0 || NeedValue + offset > hTlen - 1)
        {
            hashTable[nums[i]+offset] = 0;
            continue;
        }

Two sum这个函数是我们的核心，首先定义NeedValue, 它不同于target，它等于target减去第二个数，也就是说它是我们想要的第三个数的值。然后我们从第一个数的下一个位置开始做为第二个数，这样保证了，第二个数b始终在第一个数a的后面，这样就避免了和之前搜索结果重复的情况，同样第三个数c一定在第二个数b后面，否则，我们就会在搜索到b之前，先搜索到第三个数c，之后我们就会找到b作为第三个数，找到这个组合后，我们会把b，c对应的hash表都置为0，因此在遇到b时直接跳过，不会搜索。而我们现在在搜索b，就说明第三个数c一定在b后面，同时b一定在a后面。 在循环中，我们首先查看当前正在搜索的值对应的hash值，如果为0，那么这个值不可用，直接跳过，找下一个搜索值。否则对应的hash值减1，我们采用当前搜索值作为第二个数，所以剩下的具有这个值的可用的数少了一个。在确定第二个值之后我们，就可以确定我们需要的第三个值了，如果我们想要的第三个值对应的索引值不在hash表范围内，那么必然不存在，所以把第二个值对应的hash表的值置为0，因为第二个值选它不可能找到匹配，然后进入下一次迭代。

        if(hashTable[NeedValue+offset])
        {
            result[count] = (int*)malloc(sizeof(int) * 3);
            result[count][0] = nums[i] < NeedValue ? nums[i] : NeedValue;
            result[count][1] = nums[i] > NeedValue ? nums[i] : NeedValue;

            if(current >= result[count][1])
                result[count][2] = current;
            else if(current < result[count][1] && current >= result[count][0])
            {
                result[count][2] = result[count][1];
                result[count][1] = current;
            }
            else
            {
                result[count][2] = result[count][1];
                result[count][1] = result[count][0];
                result[count][0] = current;
            }

            count++;
        }

        hashTable[NeedValue+offset] = 0;
        hashTable[nums[i]+offset] = 0;
    }，
    *returnSize = count;
}

如果需要的值刚好在，那么我们就找到了一个符合要求的三维组，然后我们按由小到大的顺序把它们排好，存到result中，然后把第二个数和第三个数对应的hash表的值置为0，因为如果之后再遇到第二个值，那么要想符合要求也只能找第三个值，而这我们已经找到过了，所以忽略掉，如果再遇到第三个值，那么它也只能找第二个值，所以同样忽略掉。另外如果需要的值不存在，同样把第二个值和第三个值对应的hash表的值置为0，其实第三个值的值已经是0，这就是说以后再遇到第二个值，可以忽略，因为它只能找第三个值，而第三个值不可取，所以不能成功。

下面是完整程序代码：

#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

void twoSum(int* nums, int numsSize, int* returnSize, int *hashTable, int hTlen, int target, int start, int offset, int**result, int current)
{
    int NeedValue;

    int count = *returnSize;
    for(int i = start; i < numsSize; i++)
    {
        if(!hashTable[nums[i]+offset])
            continue;
        hashTable[nums[i]+offset]--;
        NeedValue = target - nums[i];
        if(NeedValue + offset < 0 || NeedValue + offset > hTlen - 1)
        {
            hashTable[nums[i]+offset] = 0;
            continue;
        }
        if(hashTable[NeedValue+offset])
        {
            result[count] = (int*)malloc(sizeof(int) * 3);
            result[count][0] = nums[i] < NeedValue ? nums[i] : NeedValue;
            result[count][1] = nums[i] > NeedValue ? nums[i] : NeedValue;

            if(current >= result[count][1])
                result[count][2] = current;
            else if(current < result[count][1] && current >= result[count][0])
            {
                result[count][2] = result[count][1];
                result[count][1] = current;
            }
            else
            {
                result[count][2] = result[count][1];
                result[count][1] = result[count][0];
                result[count][0] = current;
            }

            count++;
        }

        hashTable[NeedValue+offset] = 0;
        hashTable[nums[i]+offset] = 0;
    }
    *returnSize = count;
}

int** threeSum(int* nums, int numsSize, int* returnSize)
{
    if(numsSize == 0)
        return NULL;
    int min_element = 100000000;
    int max_element = -100000000;
    for(int i = 0; i < numsSize; i++)
    {
        if(min_element > nums[i])
            min_element = nums[i];
        if(max_element < nums[i])
            max_element = nums[i];
    }

    int offset = -1* min_element;

    int *hashTable = (int*)malloc(sizeof(int) * (max_element - min_element + 1));

    memset(hashTable, 0, sizeof(int) * (max_element - min_element + 1));
    for(int i = 0; i < numsSize; i++)
    {
        hashTable[nums[i] + offset]++;
    }

    int **result = (int**)malloc(sizeof(int*) * 300);
    *returnSize = 0;
    for(int i = 0; i < numsSize; i++)
    {
        int target = -1 * nums[i];
        int *newHashTable = (int*)malloc(sizeof(int) * (max_element - min_element + 1));
        memcpy(newHashTable, hashTable, sizeof(int) * (max_element - min_element + 1));
        if(newHashTable[nums[i] + offset] > 0)
            newHashTable[nums[i] + offset]--;
        else if(newHashTable[nums[i] + offset] == 0)
            continue;
        //else if(newHashTable[nums[i] + offset] < 0)
            //cout<<"asdfadsfasdfasdfasdfasdf";
        twoSum(nums, numsSize, returnSize, newHashTable, max_element - min_element + 1, target, i+1, offset, result, nums[i]);
        hashTable[nums[i] + offset] = 0;

    }

    return result;
}

int main()
{
    int nums[300], numsSize = 0, returnSize = 0;

    cout<<"Input the numSize:"<<endl;
    cin>>numsSize;

    for(int i = 0; i < numsSize; i++)
    {
        cin>>nums[i];
    }


    int **result = threeSum(nums, numsSize, &returnSize);

    for(int i = 0; i < returnSize; i++)
    {
        cout<<result[i][0]<<" "<<result[i][1]<<" "<<result[i][2]<<endl;;
    }

    return 0;
}
javays1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode15 3Sum（C++）
cbb944131226的博客
09-30 638
Leetcode15 3Sum（C++） 文章目录Leetcode15 3Sum（C++）题目论述思考分析code(c++) 题目论述 链接： Leetcode15 3Sum 概述： Given an array nums of n integers, are there elements a, b, c in nums such that a + b + c = 0? Find all ...
LeetCode. 15:3sum
La745739773的博客
04-27 113
Given an array nums of n integers, are there elements a, b, c in nums such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero. Note: The solution set must not con...
leetcode 15 3Sum 详细解答
qq_22210659的博客
06-12 198
leetcode 15 3Sum 详细解答 解法1 Brute Force 使用三重循环来找三个数 代码如下： 时间复杂度：O(N3)，空间复杂度O(K) 复杂度太高，不能通过。 解法2 很明显，需要降低时间复杂度，根据之前做 leetcode 167 的经验。先将数组排序后，再可以使用三个指针。 代码如下： 时间复杂度O(N2)，空间复杂度O(K) ...
LeetCode 15 3Sum（3个数的和）
nomasp
10-17 4808
翻译给定一个有n个整数的数组S，是否存在三个元素a,b,c使得a+b+c=0? 找出该数组中所有不重复的3个数，它们的和为0。备注： 这三个元素必须是从小到大进行排序。 结果中不能有重复的3个数。例如，给定数组S={-1 0 1 2 -1 4}，一个结果集为： (-1, 0, 1) (-1, -1, 2)原文Given an array S of n integers, are there ele
Leetcode 15. 3Sum (python)
qq_37821701的博客
12-27 389
题目 解法1：hash table + sort triplets 这解法T了，应该是T在遍历之前储存的pair那边。不过我个人感觉这种做法比较直观 class Solution: def threeSum(self, nums: List[int]) -> List[List[int]]: pairs = collections.defaultdict(list) n = len(nums) ans = set()
leetcode.3sum-leetcode-practice:算法实践
07-07
3sum leetcode-练习 算法实践 15. 3和 给定一个由 n 个整数组成的数组 nums，nums 中是否有元素 a、b、c 使得 a + b + c = 0？ 在数组中找到所有唯一的三元组，其总和为零。 示例输入： [-1, 0, 1, 2, -1, -4] 示例...
leetcode.3sum-leetcode:创建此存储库是为了发布各种leetcode问题的解决方案
07-07
3sum # Leetcode 解决方案以下是我在 Leetcode 上解决的一些问题，如果你喜欢/找到任何你的答案，请留下一个星。 如果你想与我联系，我在下面分享了我的 Linkedin URL。 问题 ＃ 标题 ＃ 解决方案 困难 1 二和 简单...
leetcode2sumc-3Sum:LeetCode问题15
07-06
15 给定一个由 n 个整数组成的数组 nums，nums 中是否有元素 a、b、c 使得 a + b + c = 0？ 在数组中找到所有唯一的三元组，其总和为零。 请注意，解决方案集不得包含重复的三元组。 示例 1： 输入：nums = [-1,0,1,...
leetcode2sumc-3Sum:Leetcode问题15
06-30
3总和 Leetcode 问题 15 给定一个由 n 个整数组成的数组 nums，nums 中是否有元素 a、b、c 使得 a + b + c = 0？ 在数组中找到所有唯一的三元组，其总和为零。 笔记： 解决方案集不得包含重复的三元组。 例子： 给...
python数组双指针算法求和问题LeetCode2sum3sum4sum含代码
最新发布
01-14
本文将深入探讨如何使用Python实现双指针算法来解决LeetCode中的2sum、3sum和4sum问题，并提供相关代码示例。 首先，我们来看2sum问题。给定一个整数数组`nums`和一个目标值`target`，我们需要找到数组中两个数的...
leetcode 287 Find the Duplicate Number
javays1的专栏
10-24 521
Find the Duplicate Number Total Accepted: 8673 Total Submissions: 25351 Difficulty: Hard Given an array nums containing n + 1 integers where each integer is between 1 and n (inclusive), prove t
leetcode 42 Trapping Rain Water
javays1的专栏
09-22 520
Trapping Rain Water Total Accepted: 47928 Total Submissions: 158168 Difficulty: Hard Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how mu
leetcode 13 Roman to Integer
javays1的专栏
08-24 513
Roman to Integer Total Accepted: 49270 Total Submissions: 143461 Given a roman numeral, convert it to an integer. Input is guaranteed to be within the range from 1 to 3999. 这道题刚好与上一道题相反，是
Leetcode 7 Reverse Integer
javays1的专栏
08-16 424
Reverse Integer Total Accepted: 89449 Total Submissions: 373087 Reverse digits of an integer. Example1: x = 123, return 321 Example2: x = -123, return -321 这道题比较简单，我最先采用的是字符串的方法，通过库函数
leetcode 17 Letter Combinations of a Phone Number
javays1的专栏
10-03 398
Letter Combinations of a Phone Number Total Accepted: 54389 Total Submissions: 210023 Difficulty: Medium Given a digit string, return all possible letter combinations that the number could repr
leetcode 268 Missing Number
javays1的专栏
09-19 397
Missing Number Total Accepted: 13285 Total Submissions: 39921 Difficulty: Medium Given an array containing n distinct numbers taken from 0, 1, 2, …, n, find the one that is missing from the arr
leetcode 16 3Sum Closet
javays1的专栏
10-03 364
3Sum Closest Total Accepted: 53147 Total Submissions: 195388 Difficulty: Medium Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target.
leetcode 11 Container With Most Water
javays1的专栏
08-23 356
Container With Most Water Total Accepted: 48739 Total Submissions: 153072 Given n non-negative integers a1, a2, …, an, where each represents a point at coordinate (i, ai). n vertical lines are
leetcode 10 Regular Expression Matching
javays1的专栏
08-22 319
Regular Expression Matching Total Accepted: 51566 Total Submissions: 249926 Implement regular expression matching with support for ‘.’ and ‘*’. ‘.’ Matches any single character. ‘*’ Ma
leetcode tosum
07-27
LeetCode题目“Two Sum”是一个非常经典且常见的问题。这个问题要求在一个给定的整数数组中，找到两个数的和等于给定目标值，然后返回这两个数的索引。 我们可以使用暴力解法来解决这个问题。具体步骤如下： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值