leetcode学习——移出元素(双指针法）

最新推荐文章于 2024-07-21 15:36:00 发布

小小程序媛(*^▽^*)

最新推荐文章于 2024-07-21 15:36:00 发布

阅读量58

点赞数

分类专栏： leetcode刷题笔记文章标签： leetcode 学习算法 c++ 笔记

本文链接：https://blog.csdn.net/qq_50714222/article/details/133500251

版权

leetcode刷题笔记专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本章介绍了删除数组中元素的两种方法——暴力法和双指针法。使用双指数法可以将时间复杂度减少为O(n),对于下面的题，都可以使用这两种法方法来解题，按照从简到难的顺序排列，其中977. 有序数组的平方这道题和删除元素没有关系，但是也是双指针的解法，所以也加入到了本章的内容。

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

283. 移动零

844. 比较含退格的字符串

977. 有序数组的平方

数组中移除元素思路

数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。一般有两种解法：暴力解法和双指针解法。

暴力法

两层for循环，一个for循环遍历数组元素，第二个for循环更新数组。

时间复杂度是O(n^2)，空间复杂度：O(1)。

27.移除元素-暴力解法

双指针法

双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。

双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

定义快慢指针

快指针：寻找新数组的元素，新数组就是不含有目标元素的数组
慢指针：指向更新新数组下标的位置

删除过程如下：

时间复杂度是O(n)，空间复杂度：O(1)

27.移除元素-双指针法

相向双指针方法

定义两个指针，一个指针left从左向右找到等于val的值;另外一个指针right从右往左找到有不等于val的元素;然后将左边等于val的元素和右边不等于val的元素交换位置。直到left>right跳出循环.

优点：可以最少挪动元素的位置

缺点：会改变数组中元素的相对位置顺序。

27. 移除元素

题目链接：27. 移除元素

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

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

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

示例 1:

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例 2:

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回信的长度5，且nums中的前五个元素应为0 1 3 0 4.这五个元素可以为任意顺序，不需要考虑数组中超出长度后面的元素。

暴力法代码

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size();
        for (int i = 0; i < size; i++) {
            if (nums[i] == val) {//当发现相等时，将后面的元素都往前挪一位
                for (int j = i; j < size-1; j++) {//注意边界的控制
                    nums[j] = nums[j+1];
                }
                i --;//因为nums[i] == val,将其值改变了，所以需要-1再吧、判断一次
                size --;//更新size长度
            }
        }
        return size;
    }
};

双指针法代码

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size();
        int low = 0;//定义慢指针
        for (int fast = 0; fast < size; fast++) {//fast为快指针
            if (nums[fast] != val) {
                nums[low++] = nums[fast];//当值不一样时给新数组赋值
            }
        }
        return low;//慢指针的大小刚好为新数组的大小
    }
};

相向双指针方法代码

基于元素顺序可以改变的题目描述改变了元素相对位置，确保了移动最少元素。

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size();
        int left = 0;
        int right =size -1;
        while (left <= right) {
            // 从左往右找到左边等于val的元素
            while (left <= right && nums[left] !=val) {
                left ++;
            }
            // 从右往左找到有不等于val的元素
            while (left <= right && nums[right] ==val) {
                right --;
            }
            // 将左边等于val的元素和右边不等于val的元素交换位置
            if (left < right) {
                nums[left++] = nums[right--];
            }
        }
            
        return left;// left 为新数组的大小
    }
};

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

题目链接：26. 删除有序数组中的重复项

题目描述:给你一个 非严格递增排列 的数组 nums ，请你原地删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持一致。然后返回 nums 中唯一元素的个数。不需要考虑数组中超出新长度后面的元素。

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

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

示例 1：

输入：nums = [1,1,2]
输出：2, nums = [1,2,_]

示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]

解题分析：这题和单纯的删除元素很像，不需要很大的变通。主要分为两步：

判断当前元素是否和后一位元素相等，不相等则赋值；
将最后一个元素补上，因为前面的区间无法遍历到，由于后面没有元素，所以肯定不会重复；

暴力法

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int size = nums.size();
        for (int i = 1; i < size; i++) {
            // 当元素前后相等时，需要挪动删除元素
            if (nums[i] == nums[i-1]) {
                for (int j = i; j < size-1; j++) {
                    nums[j] =nums[j+1];
                }
                // 需要对i值和size值进行更新
                i --;
                size --;
            }
        }
        return size;
    }
};

双指针法

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int low = 0;
        int size = nums.size();
        for (int fast = 0; fast < size-1; fast ++) {
            // 判断当前元素是否和后一位元素相等，不相等则赋值
            if (nums[fast] != nums[fast+1]) {
                nums[low++] =nums[fast];
            }
        }
        // 将最后一个元素补上，因为前面的区间无法遍历到，由于后面没有元素，所以肯定不会重复
        nums[low] = nums[size - 1];
        return low + 1;
    }
};

283. 移动零

题目链接：283. 移动零

题目描述：给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:

输入: nums = [0,1,0,3,12]
输出：[1,3,12,0,0]

示例 2:

输入: nums = [0]
输出：[0]

解题分析：这题就是在上一题26. 删除有序数组中的重复项的解题基础上多了一步，即当循环结束后，需要将数字从low指针到原数组大小位置的元素均赋值为0。相当于先删除0，然后再数组末尾补充对应删除个数的0。

双指针法需要挪动元素的个数小于暴力法，但此题暴力法也可以通过测试。

暴力法

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int size = nums.size();
        for (int i = 0; i < size; i++) {
            // 当元素前后相等时，需要挪动删除元素
            if (nums[i] == 0) {
                int j;
                for (j = i; j < size-1; j++) {
                    nums[j] =nums[j+1];
                }
                nums[j] = 0;
                // 需要对i值和size值进行更新
                i --;
                size --;
            }
        }
    }
};

双指针法

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int size = nums.size();
        int low = 0;//定义慢指针
        for (int fast = 0; fast < size; fast++) {//fast为快指针
            if (nums[fast] != 0) {
                nums[low++] = nums[fast];//当值不一样时给新数组赋值
            }
        }
        // 给多余的位置赋0
        for (int i = low; i < size; i++){
            nums[i] = 0;
        }
    }
};

844. 比较含退格的字符串

题目链接：844. 比较含退格的字符串

题目描述：给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

注意：如果对空文本输入退格字符，文本继续为空。

示例 1：

输入：s = "ab#c", t = "ad#c"
输出：true
解释：s 和 t 都会变成 "ac"。

示例 2：

输入：s = "ab##", t = "c#d#"
输出：true
解释：s 和 t 都会变成 ""。

示例 3：

输入：s = "a#c", t = "b"
输出：false
解释：s 会变成 "c"，但 t 仍然是 "b"。

提示：

s 和 t 只含有小写字母以及字符 '#'

进阶：

你可以用 O(n) 的时间复杂度和 O(1) 的空间复杂度解决该问题吗？

解题分析：此题有两种主要的方式解题：暴力法和双指针法。

一、暴力法：

使用栈处理遍历过程，每次遍历到一个字符：

如果它是退格符#，那么调用pop_back()函数将栈顶弹出；
如果它是普通字符，那么调用push_back()函数将其压入栈中；

暴力法代码

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        return builder(s) == builder(t);
    }
    string builder(string str) {
        string ret;
        for (auto ch : str) {
            // 如果字符不是#,则直接加入到新的字符串 
            if (ch != '#') {
                ret.push_back(ch);
            }
            // 如果字符是#，且新字符串非空，则将上一个字符跳出
            else if (!ret.empty()) {
                ret.pop_back();
            }
        }
        return ret;
    }
};

时间复杂度O(N+M)
空间复杂度O(N+M)

N和M分别为两个字符串的长度。

双指针法：

通过双指针法分别将两个字符串遍历处理得到回退后的字符串。

如果是回退符#，且慢指针slow非空，则回退一个，slow--;
如果不是回退符#，则赋值并向右挪动一个，S[slow++]=fast;
循环结束后调佣substr函数截取字符串前slow部分作为返回值进行比较；

以字符串s=“ab#c”为例，操作如下：

双指针法代码

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        // 调用修改后的函数字符串进行比较
        return build(s) == build(t);
    }
    string build(string str) {
        int slow = 0;
        for (auto fast: str) {
            // 使用快慢指针一起遍历
            // 如果快指针不是#，则给慢指针赋值，并指向下一位
            if (fast != '#') {
                str[slow++] =fast;
            }
            // 如果快指针是#，则当慢指针不为空时，需要对慢指针进行回退
            else if (slow > 0) {
                slow --;
            }
        }
        //只截取slow长度，即慢指针新赋值过的
        return str.substr(0, slow);
    }
};

时间复杂度O(N+M)
空间复杂度O(1)

N和M分别为两个字符串的长度。

977.有序数组的平方

题目链接：977. 有序数组的平方

题目描述：给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

进阶：

请你设计时间复杂度为 O(n) 的算法解决本问题

解题分析：有两种方法：暴力法和双指针法。

暴力法：直接计算乘积结束后调用sort函数排序

暴力法代码

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
       for (int i = 0; i < nums.size(); i++) {
           nums[i] *= nums[i];
       } 
         //  调用sort函数
        sort(nums.begin(), nums.end());
        return nums;
    }
};

时间复杂度：O(nlogn),空间复杂度：O(1)

双指针法：

left从最左端0开始往右挪，right从最右端开始往左挪
右边的乘积结果大于左边，存储右边的值，并挪动right指针（right--）
左边的乘积结果大于右边，存储左边的值，并挪动left指针(left++)
直到left>right 结束循环

以示例1的数据为例，计算过程如下：

双指针法代码

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        // 注意给数组赋初值
       vector<int> ans(nums.size(),0);
       int left = 0;
       int right = nums.size()-1;
       int k = nums.size() - 1;
       while(left <= right) {
        //    右边的乘积结果大于左边，存储右边的值，并挪动right指针
           if(nums[left] * nums[left] < nums[right] * nums[right]) {
               ans[k--] = nums[right] *nums[right];
               right--;
           }
        //   左边的乘积结果大于右边，存储左边的值，并挪动left指针 
        else {
               ans[k--] =nums[left] *nums[left];
               left++;
           }
       }
       return ans;
    }
};

时间复杂度：O(n), 空间复杂度O(1)。

小小程序媛(*^▽^*)

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
leetcode学习——移出元素(双指针法）

本章介绍了删除数组中元素的两种方法——暴力法和双指针法。使用双指数法可以将时间复杂度减少为O(1),对于下面的题，都可以使用这两种法方法来解题，按照从简到难的顺序排列，其中977. 有序数组的平方这道题和删除元素没有关系，但是也是双指针的解法，所以也加入到了本章的内容。
复制链接

扫一扫