【爆刷力扣-数组】双指针(快慢指针)

双指针原理

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

【leetcode 27】移除元素

暴力解法

// 时间复杂度：O(n^2)
// 空间复杂度：O(1)
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 + 1; j < size; j++) {
                    nums[j - 1] = nums[j];
                }
                i--; // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                size--; // 此时数组的大小-1
            }
        }
        return size;

    }
};

双指针法

// 时间复杂度：O(n)
// 空间复杂度：O(1)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
            if (val != nums[fastIndex]) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
};

【leetcode 26】删除有序数组中的重复项

方法一

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if (nums.empty()) { 
            return 0;
        }
        int slow = 1;
        for(int fast = 1; fast < nums.size(); fast++){
            if(nums[fast] != nums[fast - 1]){
                nums[slow++] = nums[fast];
            }
        }
        return slow ;
    }
};

方法二

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if (nums.empty()) { 
            return 0;
        }
        int slow = 0;
        for(int fast = 1; fast < nums.size(); fast++){
            if(nums[fast] != nums[slow]){
                nums[++slow] = nums[fast];
            }
        }
        return slow + 1;
    }
};

【leetcode 283】移动零

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int slow = 0;
        for(int fast = 0; fast < nums.size(); fast++){
            if(nums[fast]){
                swap(nums[slow] , nums[fast]);
                slow++;
            }
        }
    }
};

【leetcode 844】比较含退格的字符串

class Solution {
    public:
        string word(string str){
            string ret;
            for(char ch : str){
                if(ch != '#'){
                    ret.push_back(ch);
                }else if(!ret.empty()){
                    ret.pop_back();
                }
            }
            return ret;
        }

        bool backspaceCompare(string s, string t) {
            int slow = 0;
            return word(s) == word(t);
        }
};

【leetcode 977】 有序数组的平方

直接排序

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> ans;
        for(int num:nums){
            ans.push_back(num*num);
        }
        sort(ans.begin(),ans.end());
        return ans;
    }
};



class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        for (int i = 0; i < A.size(); i++) {
            A[i] *= A[i];
        }
        sort(A.begin(), A.end()); // 快速排序
        return A;
    }
};

双指针法

定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。

如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j]; 。

如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i]; 。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        int k = A.size() - 1;
        vector<int> result(A.size(), 0);
        for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
            if (A[i] * A[i] < A[j] * A[j])  {
                result[k--] = A[j] * A[j];
                j--;
            }
            else {
                result[k--] = A[i] * A[i];
                i++;
            }
        }
        return result;
    }
};