数组-移除元素

目录

题目链接：27. 移除元素 - 力扣（LeetCode）

题目链接：26. 删除有序数组中的重复项 - 力扣（LeetCode）

题目链接：283. 移动零 - 力扣（LeetCode）

题目链接：844. 比较含退格的字符串 - 力扣（LeetCode）

题目链接：977. 有序数组的平方 - 力扣（LeetCode）

---

题目链接：27. 移除元素 - 力扣（LeetCode）

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        // 设前后两个指针，从前面和后面同时遍历
        int p=0,q=nums.size()-1;
        // 用于交换两个数
        int temp;
        // 当两个指针不错过时
        while(p<=q)
        {
            //注意这里要先判断交换。因为如果不先判断判断，有可能left走到right后面
            // 如果前指针指向的数=val且后指针指向的数不=val，那么可以交换
            if(nums[p]==val&&nums[q]!=val)
            {
                temp=nums[p];
                nums[p]=nums[q];
                nums[q]=temp;
            }
            // 如果前指针指向的数不=val则前指针继续向后
            if(nums[p]!=val)
            {
                p++;
            }
            // 如果后指针指向的数=val则后指针继续向前
            if(nums[q]==val)
            {
                q--;
            }
        }
        // 最后前p个都不=val，即新数组的长度
        return p;
    }
};

题目链接：26. 删除有序数组中的重复项 - 力扣（LeetCode）

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        // fast指向下一个不重复的数，slow指向下一个要赋值的位置
        int fast=-1,slow=-1;
        int len=nums.size();
        // slow=第一个重复元素位置
        for(int i=1;i<len;i++)
        {
            if(nums[i]==nums[i-1])
            {
                slow=i;
                break;
            }
        }
        // 如果数组中存在重复元素，则slow>0
        if(slow>0)
        {
            // fast从slow向后走，直到找到不重复的元素
            fast=slow+1;
            while(fast<len)
            {
                // 当fast指向的数不=slow指向的数的前一个，则将fast指向的数赋给slow位置
                // slow向后走，指向下一个要赋值的位置
                if(nums[fast]!=nums[slow-1])
                {
                    nums[slow]=nums[fast];
                    slow++;
                }
                // fast向后走，继续寻找不=slow指向的数的前一个数的位置
                fast++;
            }
            // 最终前slow个数即为新数组
            return slow;
        }
        // 如果没有重复的数，则返回原数组
        return len;
    }
};

题目链接：283. 移动零 - 力扣（LeetCode）

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int fast = -1, slow = -1;
        int len = nums.size();
        // 找到第一个=0的元素下标
        for (int i = 0; i < len; i++)
        {
            if (nums[i] == 0)
            {
                slow = i;
                break;
            }
        }
        // 如果数组中有=0的元素，则slow一定>=0
        if (slow >= 0)
        {
            // fast从slow向后寻找不=0的元素与slow位置交换
            fast = slow + 1;
            while (fast < len)
            {
                if (nums[fast] != 0 && nums[slow] == 0)
                {
                    nums[slow] = nums[fast];
                    nums[fast] = 0;
                    slow++;
                }
                // slow永远停在=0的位置，等待交换
                if (nums[slow] != 0)
                {
                    slow++;
                }
                fast++;
            }
        }
    }
};

题目链接：844. 比较含退格的字符串 - 力扣（LeetCode）

感觉还是没有弄懂快慢指针orz，写了好久

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        return getString(s)==getString(t);
    }
private:
    // 得到新字符串
    string getString(string s)
    {
        int len = s.size();
        // fast指向下一个能替换slow的字符，slow永远指向下一个等待替换的字符
        int fast = -1, slow = -1;
        // 找到字符串中第一个#的位置，令slow=#的前一个位置（因为要被替换），fast=#的后一个
        for (int i = 0; i < len; i++)
        {
            if (s[i] == '#')
            {
                fast = i+1;
                slow = i - 1>=0?i-1:0;
                break;
            }
        }
        // 如果字符串中有#则fast>0，如果字符串中没有#则fast为初始值-1
        if (fast > 0)
        {
            // 当fast遍历完整个字符串，则没有能替换的字符了
            while (fast < len)
            {
                // 当fast指向的字符不=#时，用fast字符替换slow字符，slow向后走
                if (s[fast] != '#')
                {
                    s[slow] = s[fast];
                    slow++;
                }
                // 如果fast字符=#则说明此时slow指向的前一个字符也要被替换，则slow--
                // 但如果此时slow=0，则无法再往前，slow不动
                else if (s[fast] == '#'&&slow!=0)
                {
                    slow--;
                }
                // fast往后走
                fast++;
            }
            // 字符串遍历完成后，slow指向下一个等待替换的字符，所以0-slow-1是新的字符串，擦除slow之后的字符
            s.erase(slow, len - slow);
        }
        return s;
    }
};

题目链接：977. 有序数组的平方 - 力扣（LeetCode）

class Solution {
public:
    // 这道题算出来直接排序就可以，但是想用快慢指针写
    // 我感觉我都不知道是怎么写的……
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> numSort;
        int slow = -1, fast = -1;
        int len = nums.size();
        int left = 0, right = len - 1;
        int middle = 0;
        // 二分查找正负数的分界点
        while (left <= right)
        {
            middle = (left + right) / 2;
            if (nums[middle] == 0)
            {
                // 如果找到0则fast指向0,slow指向fast的前一个，即负数的开端
                fast = middle;
                slow=fast-1;
                break;
            }
            else if (nums[middle] > 0)
            {
                right = middle - 1;
            }
            else
            {
                left = middle + 1;
            }
        }
        // 如果找不到0则找到0的插入位置，插入位置为正数，前一位为负数
        if (fast == -1)
        {
            fast = right + 1;
            slow = fast - 1;
        }
        int fast2;
        int slow2;
        // 如果数组没有遍历完则继续遍历
        while (fast < len || slow >= 0)
        {
            // 如果正数部分遍历完毕，则只遍历剩下的负数部分
            if (fast >= len)
            {
                while (slow >= 0)
                {
                    slow2 = pow(nums[slow], 2);
                    numSort.push_back(slow2);
                    slow--;
                }
            }
            // 如果负数部分遍历完毕，则只遍历剩下的正数部分
            else if (slow < 0)
            {
                while (fast < len)
                {
                    fast2 = pow(nums[fast], 2);
                    numSort.push_back(fast2);
                    fast++;
                }
            }
            // 如果正数、负数部分都没有遍历完毕
            else
            {
                slow2 = pow(nums[slow], 2);
                fast2 = pow(nums[fast], 2);
                // 比较fast、slow指向的数的平方，小的填入新数组
                if (fast2 > slow2)
                {
                    numSort.push_back(slow2);
                    slow--;
                }
                else
                {
                    numSort.push_back(fast2);
                    fast++;
                }
            }
        }
        return numSort;
    }
};

上面是自己瞎写的，后来看代码随想录发现贼简单人傻了

class Solution {
public:

    vector<int> sortedSquares(vector<int>& nums) {
    
    //突然发现代码随想录不是这么写的
    //不用寻找正负分界处，直接从头尾比较,结果数组从后面排
    //因为头尾一定是平方最大的，越往中间走越小
    int slow=0,fast=nums.size()-1;
    vector<int> res(nums.size(),-1);
    int i=res.size()-1;
    while(slow<=fast)
    {
        if(nums[slow]*nums[slow]>=nums[fast]*nums[fast])
        {
            res[i]=nums[slow]*nums[slow];
            slow++;
        }
        else
        {
            res[i]=nums[fast]*nums[fast];
            fast--;
        }
        i--;
    }
    return res;
    }
};