算法刷题小结---几数之和-CSDN博客

作者简介：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;
    }
};

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

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

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

你可以假设除了数字 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;
    }
};

💙 三数之和（双指针）

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

此题方法用双指针

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

算法分析:

需要先固定一个数num[i]
去遍历剩下两个数，如果用暴力就是两重循环，加上固定的前一个数，就是三重循环，这样时间复杂度就会超时，这里遍历采用的方法是利用双指针前面遍历，这样就能将两重循环降低为一重循环
另外还有一个问题就是需要考虑答案中不包含重复元素，我们在这里就需要降重，简单做法就是在排序后的数列中与后面一个元素进行判断是否相等
下面的代码中位置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;
    }
};

💜 四数之和（双指针）

给你一个由 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;
    }
};