算法刷题小结---几数之和

​
​

作者简介：C/C++ 、Golang 领域耕耘者，创作者
个人主页：作者主页
专栏地址： 从原理解析go语言
刷题专栏：leetcode专栏
如果感觉博主的文章还不错的话，还请关注➕ 、点赞👍 、收藏🧡三连支持一下博主哦~~~

🧡 前言

今天我们有由最基础的算法题入手------两数之和。
随后引入三数之和、四数之和，来分析出题人是怎么的一步一步深入的，以及我们后面对问题扩展如何思考。

💛 两数之和（哈希法）

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

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

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

算法分析： 这题我们直接用哈希表做就行。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> re;
        unordered_map<int, int> hash;  // 记录该数出现的位置
        for(int i=0; i<nums.size(); i++)
        {
            int other = target - nums[i];
            if(hash.count(other))
            {
                re = vector<int>({hash[other], i});
                break;
            }
            hash[nums[i]] = i;
        }
        return re;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

💚 链表的两数相加（模拟法）

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

算法分析： 此题需要模拟竖式加法的过程即可。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* ret = new ListNode(0);
        ListNode* cur = ret;

        int sum = 0;
        while(1)
        {
            if(l1 != nullptr)
            {
                sum += l1->val;
                l1 = l1->next;
            }

            if(l2 != nullptr)
            {
                sum += l2->val;
                l2 = l2->next;
            }
            cur->val = sum % 10;
            sum /= 10;
            if(l1 != nullptr || l2 != nullptr || sum)
                cur = (cur->next = new ListNode(0));
            else
                break;
        }
        return ret;
    }
};

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

💙 三数之和（双指针）

给你一个包含 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]
输出：[]

此题方法用双指针

双指针的思路核心是需要有序

算法分析:

1. 需要先固定一个数num[i]
2. 去遍历剩下两个数，如果用暴力就是两重循环，加上固定的前一个数，就是三重循环，这样时间复杂度就会超时，这里遍历采用的方法是利用双指针前面遍历， 这样就能将两重循环降低为一重循环
3. 另外还有一个问题就是需要考虑答案中不包含重复元素，我们在这里就需要降重， 简单做法就是在排序后的数列中与后面一个元素进行判断是否相等
4. 下面的代码中位置i和位置j 都进行了判重，k由于确定了前两位的元素不重复，所以k不必要判重

code:

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        // 必须有序才能用双指针算法
        vector<vector<int>> re;
        sort(nums.begin(), nums.end());
        for(int i = 0; i < nums.size(); i ++)
        {
            if(i > 0 && nums[i] == nums[i - 1]) continue;  // 降重
            for(int j = i + 1, k = nums.size() - 1; j < k; j ++)
            {
                if(j > i + 1 && nums[j] == nums[j - 1]) continue;  // 降重
                while(j < k - 1 && nums[i] + nums[j] + nums[k - 1] >= 0) k --;  // 关键
                if(nums[i] + nums[j] + nums[k] == 0)
                {
                    re.push_back({nums[i], nums[j], nums[k]});
                }
            }
        }
        return re;
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

💜 四数之和（双指针）

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

示例1：

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

示例2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

此题还是和上面三数之和类似，需要用双指针优化最后一个变量来降低时间复杂度。

code:

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> re;
        sort(nums.begin(), nums.end());
        for(int i = 0; i < nums.size(); i ++)
        {
            if (i && nums[i] == nums[ i - 1]) continue;
            for(int j = i + 1; j < nums.size(); j ++)
            {
                if(j > i + 1 && nums[j] == nums[j - 1]) continue;
                for(int k = j + 1, u = nums.size() - 1; k < u; k ++)
                {
                    if(k > j + 1 && nums[k] == nums[k - 1]) continue;
                    while(k < u - 1 && ((long)nums[i] + nums[j] + nums[k] + nums[u - 1]) >= target) u --;
                    if(((long)nums[i] + nums[j] + nums[k] + nums[u]) == target)
                        re.push_back({nums[i], nums[j], nums[k], nums[u]});
                }
            }
        }
        return re;
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

🤎 总结

两数之和可以直接用哈希表来解决。
三数之和、四数之和，求解办法就是用双指针前后遍历来降低一个变量，进而减少一重循环。

如果此篇博客对你有帮助的话，可以动一动你的小手~~~
👍 点赞，你的认可是我创作的动力！
🧡 收藏，你的青睐是我努力的方向！
✏️ 评论，你的意见是我进步的财富！

推荐一个零声学院免费公开课程，个人觉得老师讲得不错，分享给大家：Linux，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK等技术内容，立即学习