刷题笔记-移除元素

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

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

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

这道题有暴力解法和双指针法两种

首先上暴力解法

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int length = nums.size();
        if(length!=0)
        {
            for (int i = 0;i<length;i++)
            {
                if (nums[i] == val) {
                    for (int j = i; j+1 < length; j++)
                    {
                        nums[j] = nums[j + 1];
                    }
                    length--;//这一句要放在前移元素操作后面，我一开始写在了前面，if判断完就立即减小长度，导致后面前移元素时总是漏掉了最后一个
                    i--;//因为下标i以后的数值都往前移动了一位，所以i也要前移一位

                      //我第一次写的时候没写，没注意到这个细节，想了半天
                }
            }
        }
        return length;
    }
};

快慢指针

class Solution
{
public:
    int removeElement(vector<int>& nums, int val)
    {
        int length = nums.size();
        int i, j;
        for (i = 0, j = 0; j < length; j++)
        {//快指针顺序前移，慢指针只有遇到不等于val的元素时才前移，同时不断用快指针的值覆盖慢指针
            nums[i] = nums[j];
            if (nums[i] != val)i++;
        }
        return length-(j-i);
    }
};

拓展：删除有序数组中的重复项

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int length = nums.size();
        for (int i = 0; i < nums.size(); i++)
        {
            for (int j = i+1; j < nums.size(); j++)
            {
                if (nums[j] == -1)break;//遇到重复数字时令其为-1并减小数字大小，但是遇到-1时需要直接break，否则会将重复的-1也当成重复元素来执行length--操作
                if (nums[j] == nums[i])
                {
                    nums[j] = -1;
                    length--;
                }
            }
        }
        for (int i = 0, j = 0; j < nums.size(); j++)
        {
            nums[i] = nums[j];
            if (nums[i] != -1) i++;
        }
        return length;
    }
};

拓展：移动零 在不改变其他元素的相对位置基础上，把零移动到数组末尾

class Solution {

public:

    void moveZeroes(vector<int>& nums) {

        int length = nums.size();

        for (int i = 0, j = 0; j < nums.size(); j++)

        {

            if (nums[j] == 0)length--;//j为快指针，i为慢指针

            nums[i] = nums[j];//不断用快指针的值覆盖慢指针的值

            if (nums[i] != 0)i++;

        }

        for (int i = length; i < nums.size(); i++) nums[i] = 0;//覆盖之后将长度为length后面的值全部赋值为0，从而实现移动0到末尾

    }

};

拓展：比较含退格的字符串

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

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

本人很菜，这是我自己写的暴力解法

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int sl = 0;
        int tl = 0;
        for (int i = 0; i < s.length(); i++)//对字符串所有的元素进行处理，执行退格操作
        {
            if (s[i] == '#')//如果遍历出#,则往前扫描
            {
                for (int j = i - 1; j >= 0; j--)
                {
                    if (s[j] != '#')//扫描出非#的元素，要消掉，令其为#
                    {
                        s[j] = '#';
                        break;
                    }
                }
            }
        }
        for (int i = 0,j=0; i < s.length(); i++)//遍历字符串，找到剩余的元素重新组建字符串
        {
            if (s[i] != '#')
            {
                s[j] = s[i];
                j++;
                sl++;
            }
        }

        for (int i = 0; i < t.length(); i++)
        {
            if (t[i] == '#')//如果遍历出#,则往前扫描
            {
                for (int j = i - 1; j >= 0; j--)
                {
                    if (t[j] != '#')//扫描出非#的元素，要消掉，令其为#
                    {
                        t[j] = '#';
                        break;
                    }
                }
            }
        }
        for (int i = 0, j = 0; i < t.length(); i++)
        {
            if (t[i] != '#')
            {
                t[j] = t[i];
                j++;
                tl++;
            }
        }

        if (sl == tl)
        {
            for (int i = 0; i < sl; i++)
            {
                if (s[i] != t[i]) return false;
            }
            return true;
        }
        else {
            return false;
        }
    }
};

大佬写的快慢指针法

class Solution {
public:
    string dealBackspace(string s) {
        int slow = 0, fast = 0;
        for (; fast < s.size(); fast++) {
            if (s[fast] != '#')
                s[slow++] = s[fast];
            else if (slow > 0){ //第一个为#则不用回退
                slow--;
            }
        }
        return s.substr(0, slow);
    }

    bool backspaceCompare(string s, string t) {
        return dealBackspace(s) == dealBackspace(t);
    }
};

拓展：最后一题 有序数组的平方 这题很简单，就不写注释了

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

暴力解法

class Solution {

public:

    vector<int> sortedSquares(vector<int>& nums) {

        for (int i = 0; i < nums.size(); i++)

        {

            nums[i] = nums[i] * nums[i];

        }

        sort(nums.begin(), nums.end());

        return nums;

    }

};

双指针法

class Solution

{

public:

    vector<int> sortedSquares(vector<int>& nums)

    {

        vector<int> result(nums.size(),0);

        auto front = nums.begin();

        auto back = nums.end()-1;

        for (int i = 0; i<nums.size(); i++)

        {

            if ((*front) * (*front) >= (*back) * (*back))

            {

                result[nums.size() - 1 - i] = (*front) * (*front);

                front++;

            }

            else

            {

                result[nums.size() - 1 - i] = (*back) * (*back);

                back--;

            }

        }

        return result;

       

    }

};