LeetCode-02day

qishuiye

已于 2023-07-05 22:28:53 修改

阅读量339

点赞数

分类专栏： LeetCode 文章标签： leetcode 算法职场和发展

于 2023-07-04 23:15:00 首次发布

本文链接：https://blog.csdn.net/qishuiye/article/details/131534323

版权

LeetCode 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章目录

LeetCode16-最接近的三数之和
- 1.算法题目
- 2.算法思路
LeetCode18-四数之和
- 1.算法题目
- 2.算法思路
LeetCode-26删除有序数组中的重复项
- 1.算法题目
- 2.算法思路
LeetCode-27移除元素
- 1.算法题目
- 2.算法思路
LeetCode-31下一个排列
- 1.算法题目
- 2.算法思路

LeetCode16-最接近的三数之和

1.算法题目

给你一个长度为 n 的整数数组 nums 和一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

2.算法思路

双指针法
本题和前面的三数之和很相似，也可以使用双指针来解决，首先定义一个变量来存放最开始的答案，以数组的前三个为基础答案，之后进行sort函数排序，再来就是使用双指针了，刚开始还是进项去重，然后使用while循环来找值，第一个判断函数判断是否直接等于target值，如果是就直接返回，如果是三数之和大于target值就先判断当前三个值减去target值的绝对值和最开始的三个值减去target值的绝对值谁小，小的就重新赋值给答案存储参数ans，之后再次进行相应的指针移动，最后在最外层返回res参数。

代码如下：

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        int ans = nums[0] + nums[1] + nums[2];//最开始的答案
        sort(nums.begin(),nums.end());
        for(int i = 0;i<nums.size();++i){
            //去重
            if(i>0 && nums[i] == nums[i-1]){
                continue;
            }
            int left = i+1,right = nums.size()-1;
            while(left < right){
                int sum = nums[i]+nums[left]+nums[right];
                if(sum == target)//如果和为target直接返回
                    return target;
                else if(sum > target){
                    ans = abs(sum-target) < abs(ans - target)?sum:ans;
                    --right;
                }
                else{
                    ans = abs(sum-target) < abs(ans - target)?sum:ans;
                    ++left;
                }
            }
        }
        return ans;
    }
};

这个双指针总体和三数之和的双指针差别不打，就是去重减少了和加了判断绝对值。

暴力枚举法
这个如果进行暴力枚举，也是能解决并且在这个题目中能运行过去不会超出时间限制，可能是因为题目的样例数是<10^3，没那么大。
思路：也是先建立一个参数来存放最开始的答案，之后通过三层for循环来遍历，将每一对三个值都和最开始的基础答案比较，最后返回。
友情提示：在面试中手撕代码时最好别动不动就暴力解法。

LeetCode18-四数之和

1.算法题目

给你一个由 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 你可以按任意顺序返回答案。

2.算法思路

双指针
该题目和三数之和逻辑相似，在三数之和的基础上在外面再加一层循环，并且写两个判断函数能减少时间，因为数组是经过sort函数重新排列了的，如果前面四个值加起来还比目标值小，那么这个数组一定没有符合目标值的四个数，可以直接跳出循环了，同时如果第一个数和最后三个数加起来比目标值大，那么也可以直接使用continue跳出本次循环进行下次循环，这样会减少很多没必要的算法时间。
代码如下：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        int size = nums.size();
        sort(nums.begin(),nums.end());
        if(nums.size() < 4){
            return res;
        }
        for(int i= 0;i<nums.size()-3;++i){
            //去重
            if(i>0&&nums[i] == nums[i-1]){
                continue;
            }
            //如果最小的四个数都大于目标值，那么可以直接返回了
            if((long)nums[i]+nums[i+1]+nums[i+2]+nums[i+3] > target)
                break;
            //如果第一个数和最后三个数加起来都小于目标值，那么可以进行下一次循环了
            if((long)nums[i]+nums[size-3]+nums[size-2]+nums[size-1] < target)
                continue;
            for(int j = i + 1;j < size - 2;++j){
                //去重
                if(j>i+1&&nums[j] == nums[j-1])
                    continue;
                //如果最小的四个数都大于目标值，那么可以直接返回了
                if((long)nums[i]+nums[j]+nums[j+1]+nums[j+2] > target)
                    break;
                //如果第一个数和最后三个数加起来都小于目标值，那么可以进行下一次循环了
                if((long)nums[i]+nums[j]+nums[size-2]+nums[size-1] < target)
                    continue;
                //双指针
                int left = j + 1,right = size-1;
                while(left < right){
                    long sum = (long)nums[i]+nums[j]+nums[left]+nums[right];
                    if(sum == target){
                        res.push_back({nums[i],nums[j],nums[left],nums[right]});
                        //去重
                        while(left < right && nums[left] == nums[left + 1]){
                            left++;
                        }
                        ++left;
                        while(left < right && nums[right] == nums[right-1]){
                            right--;
                        }
                        --right;
                    }
                    else if(sum > target){
                        --right;
                    }
                    else{
                        ++left;
                    }
                }
            }
        }
        return res;
    }
};

暴力解法
直接四层for循环就不多说了，算法逻辑和前面双指针里面的逻辑差不多。

LeetCode-26删除有序数组中的重复项

1.算法题目

给你一个升序排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持一致。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与
nums 的大小不重要。返回 k 。判题标准:

系统会用下面的代码来测试你的题解:
长度正确的期望答案

int k = removeDuplicates(nums); // 调用

assert k == expectedNums.length; for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i]; } ```

如果所有断言都通过，那么您的题解将被通过。

2.算法思路

直接使用双指针，m是来找重复值的，n是数组唯一值的数量，首先第一个数肯定不用管，看第二个数和前一个数作比较，如果不同那么就将这个值覆盖到当前位置n上，如果相同就将m的值加一，这样以此类推，最后得到唯一值的个数。
代码如下：

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        //双指针
        int m = 1,n = 1;
        if(nums.size() == 0)
            return 0;
        while(m<nums.size()){
            if(nums[m]!=nums[m-1]){
                nums[n] = nums[m];
                ++n;
            }
            ++m;
        }
        return n;
    }
};

本题考察的就是如何运用双指针。

LeetCode-27移除元素

1.算法题目

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

2.算法思路

还是使用双指针，题比较简单直接贴代码

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        //双指针
        int m = 0,n = 0;
        while(m<nums.size()){
            if(nums[m]!= val){
                nums[n] = nums[m];
                ++n;
            }
            ++m;
        }
        return n;
    }
};

LeetCode-31下一个排列

1.算法题目

整数数组的一个排列就是将其所有成员以序列或线性顺序排列。

例如，arr = [1,2,3] ，以下这些都可以视作 arr 的排列：[1,2,3]、[1,3,2]、[3,1,2]、[2,3,1] 。
整数数组的下一个排列是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的下一个排列就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。

例如，arr = [1,2,3] 的下一个排列是 [1,3,2] 。类似地，arr = [2,3,1] 的下一个排列是 [3,1,2] 。
而 arr = [3,2,1] 的下一个排列是 [1,2,3] ，因为 [3,2,1] 不存在一个字典序更大的排列。给你一个整数数组
nums ，找出 nums 的下一个排列。

必须原地修改，只允许使用额外常数空间。

2.算法思路

本题题目有点搞不懂，看完官方题解大体思路是：从后面往前面遍历找到不满足倒序的值，之后再在这个值的后面找刚刚比这个值大的值，将这两个值交换，之后将第一个值之后的数使用reverse函数进行翻转。我只能解释到这了。

代码如下：

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
        //保证数列大于2
        int i = nums.size()-2;

        //倒着遍历找不满足倒序的数
        while(i>=0 && nums[i] >= nums[i+1]){
            i--;
        }
        //找不满足倒序的数的后面刚刚比它打的数并进行交换
        if(i>=0){
            int j = nums.size() - 1;
            while(j >= 0 && nums[i] >= nums[j]){
                j--;
            }
            swap(nums[i],nums[j]);
        }
        //翻转
        reverse(nums.begin()+i+1,nums.end());
    }
};