两数之和->三数之和->四数之和 LeetCode1 两数之

发表于

这是我参与11月更文挑战的第17天，活动详情查看：2021最后一次更文挑战

LeetCode1 两数之和题解

题目

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

举个例子:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解题思路

思路一 暴力解法

显而易见经过两层的循环嵌套，就能把答案的两个值找出来，比较简单，时间复杂度显而易见就是O(n^2),不过这个方法比较耗时，提交了以后会超时。

思路二 哈希表法

因为哈希表查找值的时间复杂度是O(1)，所以可以利用哈希表通过key-value的方式快速查找需要的值。首先遍历一遍数组，将数组值和对应下标输入进hashmap中，之后再次遍历一次数组，对每一个数组元素nums[i]，在hashmap里寻找target-nums[i]，如果找到则找到题目答案，否则无解。

代码展示

思路一 暴力解法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
java复制代码public int[] twoSum(int[] nums, int target) {
        int a[] = new int[2];
        a[0] = a[1] = 0;
        for(int i=0;i< nums.length;i++)
        {
            for(int j=i+1;j< nums.length;j++)
            {
                if(nums[i]+nums[j]==target)
                {
                    a[0] = i;
                    a[1] = j;
                    return a;
                }
            }
        }
        
        return a;
    }

思路二 哈希表法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
java复制代码public int[] twoSum(int[] nums, int target) {
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int i=0;i< nums.length;i++)
        {
            map.put(nums[i],i);
        }
        for(int i=0;i< nums.length;i++)
        {
            int comp = target - nums[i];
            if(map.containsKey(comp)&&map.get(comp)!=i)
            {
                int a[] = new int[2];
                a[0] = i;
                a[1] = map.get(comp);
                return a;
            }
        }
        return new int[2];
    }

LeetCode15 三数之和题解

题目

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

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

举个例子：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

解题思路

思路一 暴力解法

很简单能想出来用三层循环嵌套可以暴力地解出来答案，但是时间复杂度是O(n^3)，所以没有尝试。

思路二 单层循环+双指针

为了防止输出的答案包含重复的三元组，先对原数组进行排序，可以使用自带的快速排序函数，时间复杂度为O(nlogn)。之后遍历数组，对于每个数组值nums[i]，只需要在下标i之后（在下标i之后进行寻找是为了防止重复三元组出现）找到两个数组值nums[a]和nums[b]（b>a>i），使得满足nums[a]+nums[b]==0-nums[i]。将当前数组值nums[i]、i+1（左指针）、nums.length-1（右指针）以及数组nums输入到函数Twosum（）中寻找需要的nums[a]和nums[b]。

在函数Twosum（）中是通过左右双指针寻找两个值和为 -nums[i] ，由于nums数组是有序的（从小到大），因此当nums[left]+num[right]>-nums[i] 时，将右指针左移，同理当nums[left]+num[right]<-nums[i] 时，将左指针右移。当检测到nums[left]+num[right]=-nums[i]，此时左右指针指向的数组值即为一个答案，将他们和nums[i]放进list中，同时需要移动左右指针，以左指针为例，若nums[left+1]==nums[left]，则需要右移左指针排除重复值，右指针同理。最后将左右指针各自让中间移动一次进行下一次的寻找。

举个例子

初始数组

对于数组[-1,0,1,2,-1,4]，需要三个数字使他们和为0，首先对其进行排序。

i=0

当i=0时，即nums[i]=-4，在此数组中剩余的数中不存在两个数满足和为4。

i=1

当i=1时，即nums[i]=-1，left指针指向第二个 -1，right指针指向2，此时满足条件，-1+2 = 0-（-1）

i=-1

因为left指针右侧和right指针左侧不存在重复值，因此直接各向中间移动一次，此时left指向0，而right指向1，此时满足条件，0+1 = 0-（-1）

i=3

因为当i=2时发现nums[1]==nums[2]，因此跳过i=2的情况，进入到i=3，没有符合条件的值。

代码展示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
java复制代码    public static List<List<Integer>> Twosum(int start,int end,int nums[],int value)
    {
        List<List<Integer>> list = new ArrayList<>();
        while(start<end)
        {
            if(start<end)
            {
                int a = nums[start];
                int b = nums[end];
                while(nums[start]+nums[end]>(0-value)&&start<end)
                {
                    end--;
                }
                while(nums[start]+nums[end]<(0-value)&&start<end)
                {
                    start++;
                }
                if(nums[start]+nums[end]==(0-value)&&start<end)
                {
                    List<Integer> alist = new ArrayList<>();
                    alist.add(value);
                    alist.add(nums[start]);
                    alist.add(nums[end]);
                    list.add(alist);
                    //防止重复
                    while(start!= nums.length-1&&nums[start+1]==nums[start])
                        start++;
                    while(end!=0&&nums[end]==nums[end-1])
                        end--;
                    if(start>=end)
                        break;
                    start++;
                    end--;
                }
            }

        }
        return list;
    }



    public static List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> list = new ArrayList<>();
        Arrays.sort(nums);

        for(int i=0;i< nums.length;i++)
        {
            if(i>0&&nums[i]==nums[i-1])
                continue;
            List<List<Integer>> alist = Twosum(i+1, nums.length-1,nums,nums[i]);
            for (int j=0;j<alist.size();j++)
                list.add(alist.get(j));

        }

        

        return list;
    }

LeetCode18 四数之和题解（附伪代码步骤）

题目

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

举个例子：
给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
满足要求的四元组集合为：
[
[-1, 0, 0, 1],
[-2, -1, 1, 2],
[-2, 0, 0, 2]
]

解题思路

前面写过了LeetCode第1题“两数之和”以及LeetCode第15题“三数之和”，这道题就比较简单了，思路与“三数之和”题思路类似

首先对原数组进行排序，用这种方法防止结果出现重复的四元组。之后遍历nums数组，在遍历到第i个元素nums[i]时，将第i+1的元素到最后一个元素组成一个新数组，在这个新数组中寻找三个数使得满足他们的和等于target - nums[i]，之后的步骤就可以调用三数之和的函数进行寻找。
不过需要注意的是，为了防止出现重复的四元组，在遍历nums数组时，如果nums[i]==nums[i-1]时，需要跳过此次遍历。

伪代码步骤

  • step1：对nums数组进行排序
  • step2：遍历nums数组
  • step3：如果当前数组值等于前一个数组值，那么跳过此次循环
  • step4：将当前数组值之后的数组值组成一个新的数组
  • step5：调用threesum()函数进行检索是否有满足条件的三元组
  • step6：将找到的三元组分别与当前值组成四元组

代码展示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
java复制代码public static List<List<Integer>> Twosum(int start,int end,int nums[],int value,int target)
    {
        List<List<Integer>> list = new ArrayList<>();
        while(start<end)
        {
            if(start<end)
            {
                int a = nums[start];
                int b = nums[end];
                while(nums[start]+nums[end]>(target)&&start<end)
                {
                    end--;
                }
                while(nums[start]+nums[end]<(target)&&start<end)
                {
                    start++;
                }
                if(nums[start]+nums[end]==(target)&&start<end)
                {
                    List<Integer> alist = new ArrayList<>();
                    alist.add(value);
                    alist.add(nums[start]);
                    alist.add(nums[end]);
                    list.add(alist);
                    //防止重复
                    while(start!= nums.length-1&&nums[start+1]==nums[start])
                        start++;
                    while(end!=0&&nums[end]==nums[end-1])
                        end--;
                    if(start>=end)
                        break;
                    start++;
                    end--;
                }
            }

        }
        return list;
    }



    public static List<List<Integer>> threeSum(int[] nums,int target) {
        List<List<Integer>> list = new ArrayList<>();
        Arrays.sort(nums);

        for(int i=0;i< nums.length;i++)
        {
            if(i>0&&nums[i]==nums[i-1])
                continue;
            List<List<Integer>> alist = Twosum(i+1, nums.length-1,nums,nums[i],target - nums[i]);
            for (int j=0;j<alist.size();j++)
                list.add(alist.get(j));

        }
        return list;
    }

    public static List<List<Integer>> fourSum(int[] nums,int target)
    {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);

        for (int i=0;i< nums.length-2;i++)
        {
            if(i>0&&nums[i]==nums[i-1])
                continue;
            int a[] = new int[nums.length-i-1];
            for (int j = 0;j<a.length;j++)
            {
                a[j] = nums[i+j+1];
            }
            List<List<Integer>> alist = threeSum(a,target-nums[i]);
            for (int j=0;j<alist.size();j++)
            {
                List<Integer> list = new ArrayList<>();
                list.add(nums[i]);
                for (int t=0;t<alist.get(j).size();t++)
                {
                    list.add(alist.get(j).get(t));
                }
                res.add(list);
            }
        }
        return res;
    }

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%