代码随想录 LeetCode数组篇 移除元素

已于 2023-05-06 14:09:19 修改
阅读量488 收藏
点赞数
分类专栏： 代码随想录 文章标签： leetcode 算法 数据结构
于 2023-05-06 09:05:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guliguliguliguli/article/details/130463549
版权

文章目录

（简单）27. 移除元素

在这里插入图片描述
我的思路：

简单来说，将要删除的元素放到数组的最后

当数组中的元素和val的值相同时，就和数组末尾的值进行交换。
所以，需要一个变量last指向数组的末尾。当last的位置已经放了和val相等的数值时，last向前移一位，即last–

在提交的过程中，发现还有一些特殊情况，比如：

测试用例1：
[]
0
测试用例2：
[1]
1
测试用例3
[0, 4, 4, 0, 4, 4, 4, 0, 2]
4

在这里插入图片描述

class Solution {
    public int removeElement(int[] nums, int val) {
        if (nums.length == 0) {
            return 0;
        }

        int last = nums.length - 1;
        while (last >= 0 && nums[last] == val) {
            last--;
        }
        for (int i = 0; i <= last; i++) {
            if (nums[i] != val) {
                continue;
            }
            while (last >= 0 && nums[last] == val) {
                last--;
            }
            if (last + 1 == i) {
                break;
            }
            int tmp = nums[last];
            nums[last] = nums[i];
            nums[i] = tmp;
            last--;
        }
        return last + 1;
    }
}

官方解答，方式一：双指针

分析，题目要求删除数组中等于val的元素，因此输出数组的长度一定小于等于输入数组的长度，而且，题目要求不使用额外的数组空间，那么就可以把数组直接写在输入数组上。

可以使用双指针：右指针right指向当前将要处理的元素，左指针left指向下一个将要赋值的位置。

  • 如果右指针指向的元素不等于val，那么，它一定是输出数组中的元素，就将右指针指向的元素复制到左指针位置，然后将左右指针同时右移
  • 如果右指针指向的元素等于val，那么，它就不能在输出数组里，此时左指针不动，右指针右移一位

最后，在[0,left)中的元素都不等于val。
当右指针遍历完输入数组以后，left的值就是输出数组的长度。

这样的算法，最坏的情况是，输入的数组中没有等于val的值，左右指针各遍历了数组一次。

在这里插入图片描述

class Solution {
    public int removeElement(int[] nums, int val) {
    
        if (nums.length == 0) {
            return 0;
        }

        int left = 0;
        int right = 0;
        while (right < nums.length) {
            if (nums[right] != val) {
                nums[left] = nums[right];
                left++;
            }
            right++;
        }
        return left;
    }
}

官方解答 方法二：双指针优化（和我的思路差不多）

在题目中提到，元素的顺序可以改变，当要移除的元素恰好在数组的开头，可以将数组中的最后一个元素移动到数组的开头，取代要删除的元素。

实现方面，使用双指针，两个指针初始时分别位于数组的首尾，向中间移动遍历该序列。

如果左指针left指向的元素等于val，此时将右指针right指向的元素赋值到左指针left的位置，然后右指针right左移一位。如果赋值过来的元素恰好也等于val，可以继续把右指针指向的元素赋值过来（左指针left指向的等于val的元素的位置继续被覆盖），直到左指针指向的元素的值不等于val为止。

当左指针left和右指针right重合的时候，左右指针遍历完数组中的所有元素。

这样的方法两个指针在最坏的情况下合起来只遍历了数组一次。与上面的方法一不同的是，方法二避免了需要保留的元素的重复赋值操作。

class Solution {
    public int removeElement(int[] nums, int val) {
        if (nums.length == 0) {
            return 0;
        }

        int left = 0;
        int right = nums.length - 1;
        //如果right初始化为nums.length，那么while循环的条件是<，赋值时是nums[left]=nums[right-1]
        //如果哦right初始化为nums.length-1，那么while循环条件是<=，赋值时是nums[left]=nums[right]
        //可以用nums=[1],val=1这个比较特殊的测试用例来思考
        while (left <= right) {
            if (nums[left] == val) {
                nums[left] = nums[right];
                right--;
            } else {
                left++;
            }
        }
        return left;
    }
}

（简单）26. 删除有序数组中的重复项

在这里插入图片描述
在这里插入图片描述

我的思路：使用LinkedHashSet去重，并且，LinkedHashSet可以记录添加元素的顺序
在这里插入图片描述

import java.util.LinkedHashSet;

class Solution {
    public int removeDuplicates(int[] nums) {

        LinkedHashSet<Integer> set = new LinkedHashSet<>();
        for (int num : nums) {
            set.add(num);
        }
        int index = 0;
        for (Integer i : set) {
            nums[index] = i;
            index++;
        }
        return set.size();
    }
}

其他思路：双指针

首先，题目中说明了数组是有序的，那么重复的元素一定会相邻。

要求删除重复的元素，实际上就是将不重复的元素移到数组的左侧。

考虑用两个指针，一个在前记作p，一个在后记作q，算法流程如下：

  1. 比较p和q为止的元素是否相等
  2. 相等，q后移一位
  3. 不相等，将q位置的元素复制到p+1位置上，p后移一位，q后移一位
  4. 重复1-3步，直到q等于数组长度
  5. 返回p+1，即为新数组的长度

在这里插入图片描述

class Solution {
    public int removeDuplicates(int[] nums) {
        int left = 0;
        int right = 0;
        int n = nums.length;
        while (right < n) {
            if (nums[left] != nums[right]) {
                nums[left + 1] = nums[right];
                left++;
            }
            right++;
        }
        return left + 1;
    }
}

优化：如果数组中没有重复的元素，按照上面的算法流程，每次比较时nums[p]都不等于nums[q]，因此，会将q指向的元素原地复制一遍，这个操作其实是不必要的

因此，可以添加一个小判断，当q-p>1时，才进行复制

在这里插入图片描述

class Solution {
    public int removeDuplicates(int[] nums) {
        int left = 0;
        int right = 1;
        int n = nums.length;
        while (right < n) {
            if (nums[left] != nums[right]) {
                if (right - left > 1){
                    nums[left+1] = nums[right];
                }
                left++;
            }
            right++;
        }
        return left + 1;
    }
}

（简单）283. 移动零

在这里插入图片描述
我的思路：
p指针指向当前要操作的位置，如果当前位置的数值不等于0，那么p后移一位，如果p指向的当前位置为0，那么就需要找出在p后面的不为0的数的位置q，将其值赋值到p的位置，并将q的位置赋值为0

根据题目所给的提示，如果数组的长度是 1 0 4 10^4 104，假设一个比较极端的情况，只有第一个数字是非零，后面的9999个数字都是零，那么，就会做很多无用功，导致执行用时花费很长时间

在这里插入图片描述

class Solution {
    public void moveZeroes(int[] nums) {

        int p = 0;
        int q = 0;
        int n = nums.length;
        while (p < n && q < n) {
            if (nums[p] != 0) {
                p++;
            } else {
                q = p + 1;
                while (q < n && nums[q] == 0) {
                    q++;
                }
                if (q < n) {
                    nums[p] = nums[q];
                    nums[q] = 0;
                }
            }
        }
    }
}

我的另一种思路

在这里插入图片描述

双指针p和q，一开始都指向数组位置0

  • 如果p位置的值为0，那么就要看q位置的值是否为0
    • 如果q位置的值为0，则，q后移一位
    • 如果q位置的值不为0，则将q位置上的值赋值到p的位置上，然后q位置上的值设置为0，p和q都后移一位
  • 如果p位置的值不为0，则，p和q都后移一位
class Solution {
    public void moveZeroes(int[] nums) {

        int p = 0;
        int q = 0;
        int n = nums.length;
        while (p < n && q < n) {
            if (nums[p] == 0) {
                if (nums[q] != 0) {
                    nums[p] = nums[q];
                    nums[q] = 0;
                    p++;
                }
            } else {
                p++;
            }
            q++;
        }
    }
}

其他思路

创建两个指针i和j，第一遍历的时候，指针j用来记录当前有多少非0元素。即遍历的时候每遇到一个非0元素，就将其往数组左边挪，第一次遍历完成后，j指针的下标就指向了最后一个非0元素的下标。

第二次遍历的时候，其实位置从k开始到结束，将剩下的这段区域内的元素全部置为0。

在这里插入图片描述

class Solution {
    public void moveZeroes(int[] nums) {

        int j = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != 0) {
                nums[j++] = nums[i];
            }
        }

        for (int i = j; i < nums.length; i++) {
            nums[i] = 0;
        }
    }
}

（简单）844. 比较含退格的字符串

在这里插入图片描述
在这里插入图片描述
我的思路：使用栈来模拟

在这里插入图片描述

import java.util.Stack;

class Solution {
    public boolean backspaceCompare(String s, String t) {
        Stack<Character> ss = new Stack<>();
        Stack<Character> st = new Stack<>();
        char[] charS = s.toCharArray();
        char[] charT = t.toCharArray();
        for (char c : charS) {
            if (c == '#' && !ss.isEmpty()) {
                ss.pop();
            } else if (c != '#') {
                ss.push(c);
            }
        }
        for (char c : charT) {
            if (c == '#' && !st.isEmpty()) {
                st.pop();
            } else if (c != '#') {
                st.push(c);
            }
        }
        if (ss.size() != st.size()) {
            return false;
        }
        while (!ss.isEmpty()) {
            Character c1 = ss.pop();
            Character c2 = st.pop();
            if (!c1.equals(c2)) {
                return false;
            }
        }
        return true;
    }
}

官方思路，方法一：重构字符串

看到这个题目，最容易想到的就是将给定的字符串中的退格符和应当被删除的字符都去除，还原给定字符串的一般形式。然后直接比较两个字符串是否相等即可。

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

  • 如果它是退格符，那么将栈顶弹出
  • 如果是普通字符，将其压入栈中

说是用栈，但是，使用的StringBuilder来模拟栈
在这里插入图片描述

class Solution {
    public boolean backspaceCompare(String s, String t) {
        return build(s).equals(build(t));
    }

    public String build(String str) {
        StringBuilder stringBuilder = new StringBuilder();
        int length = str.length();
        for (int i = 0; i < length; i++) {
            char c = str.charAt(i);
            if (c != '#') {
                stringBuilder.append(c);
            } else {
                if (stringBuilder.length() != 0) {
                    stringBuilder.deleteCharAt(stringBuilder.length() - 1);
                }
            }
        }
        return stringBuilder.toString();
    }
}

复杂度分析：

  • 时间复杂度：O(N+M)，其中N和M分别为字符串S和T的长度。因为需要遍历两个字符串各一次
  • 空间复杂度：O(N+M)，其中N和M分别是字符串S和T的长度。主要是使用StringBuilder还原出字符串的开销。

官方思路，方法二：双指针

一个字符是否会被删除，只取决于该字符后面的退格符，而与该字符前面的退格符无关。因此，可以逆序地遍历字符串，就可以立即确定当前字符是否会被删除掉。

具体地，定义skip表示当前待删除地字符的数量。每次我们遍历到一个字符：

  • 如果该字符为退格符，则需要多删除一个普通字符，skip+1
  • 若该字符是普通字符：
    • 若skip为0，则说明当前字符不需要删去
    • 若skip不为0，则说明当前字符需要删去，skip-1

这样，定义两个指针，分别指向两字符的末尾。每次我们让两指针逆序地遍历两字符串，直到两字符串能够各自确定一个字符，然后将这两个字符进行比较。重复这一过程直到找到的两个字符不相等，或者遍历完字符串为止。

在这里插入图片描述

class Solution {
    public boolean backspaceCompare(String s, String t) {

        int i = s.length() - 1;
        int j = t.length() - 1;

        int skipS = 0;
        int skipT = 0;

        while (i >= 0 || j >= 0) {
            while (i >= 0) {
                char c = s.charAt(i);
                if (c == '#') {
                    skipS++;
                    i--;
                } else if (skipS > 0) {
                    skipS--;
                    i--;
                } else {
                    break;
                }
            }
            while (j >= 0) {
                char c = t.charAt(j);
                if (c == '#') {
                    skipT++;
                    j--;
                } else if (skipT > 0) {
                    skipT--;
                    j--;
                } else {
                    break;
                }
            }
            if (i >= 0 && j >= 0) {
                if (s.charAt(i) != t.charAt(j)) {
                    return false;
                }
            } else {
                if (i >= 0 || j >= 0) {
                    return false;
                }
            }
            i--;
            j--;
        }
        return true;
    }
}

（简单）977. 有序数组的平方

在这里插入图片描述

我的思路：因为数组是按照非递减的顺序排列的，所以，数组两端的数的平方大于等于中间数的平方，所以从两头开始比较，然后从后往前向新数组中填数

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] res = new int[nums.length];
        int left = 0;
        int right = nums.length - 1;
        int i = nums.length - 1;
        while (left <= right) {
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
                res[i] = nums[left] * nums[left];
                left++;
            } else {
                res[i] = nums[right] * nums[right];
                right--;
            }
            i--;
        }
        return res;
    }
}

在这里插入图片描述

复杂度分析：

  • 时间复杂度：O(n)，其中n是数组nums的长度
  • 空间复杂度：O(1)。除了存储答案的数组以外，需要维护常量空间。

其他思路，双指针

如果给定数组中的数都是非负数，那么每个数平方后，数组仍然保持升序；如果数组nums中的所有数都是负数，那么将每个数平方后，数组会保持降序。

这样，就可以找到数组nums中负数与非负数的分界线neg，就可以用类似【归并排序】的方法。nums[0]到nums[neg]均为负数，nums[neg+1]到nums[n-1]均为非负数。当将数组nums中的数平方后，那么nums[0]到nums[neg]单调递减，nums[neg+1]到nums[n-1]单调递增。

由于得到了两个已经有序的子数组，因此可以使用归并的方法进行排序。使用两个指针分别指向neg和neg+1，每次比较两个指针对应的数，选择较小的那个放入答案并移动指针。当某一指针移至边界时，将另一指针还未遍历到的数一次放入答案。

在这里插入图片描述

class Solution {
    public int[] sortedSquares(int[] nums) {
        int n = nums.length;
        int neg = -1;
        for (int i = 0; i < n; i++) {
            if (nums[i] < 0) {
                neg = i;
            } else {
                break;
            }
        }

        int[] ans = new int[n];
        int i = neg;
        int j = neg + 1;
        int index = 0;
        while (i >= 0 || j < n) {
            if (i < 0) {
                ans[index] = nums[j] * nums[j];
                j++;
            } else if (j >= n) {
                ans[index] = nums[i] * nums[i];
                i--;
            } else if (nums[i] * nums[i] > nums[j] * nums[j]) {
                ans[index] = nums[j] * nums[j];
                j++;
            } else {
                ans[index] = nums[i] * nums[i];
                i--;
            }
            index++;
        }
        return ans;
    }
}
努力努力再努力@_@
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题——移除元素和两数之和
2201_75557988的博客
11-30 132
LeetCode刷题——移除元素和两数之和
php-leetcode题解之移除元素.zip
06-13
php php_leetcode题解之移除元素
LeetCode算法——数组（移除元素）
weixin_44512852的博客
04-05 117
以上三种方法，前两种属于稳定（即不改变原数组顺序）移除元素，第三种会改变数组顺序，更推荐第二种快慢指针，通过动态的方式来满足条件。请注意，输入数组是以**「引用」**方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。使用两层for循环，第一层for循环遍历数组，第二层for循环更新数组。的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。为什么返回数值是整数，但输出的答案是数组呢?时间复杂度为O(n^2)
LeetCode算法之数组篇
兮遥
05-19 344
练习数组算法题，得先了解数组的常用操作，只要熟悉这些操作才可以更好刷题。 ①创建数组 Java语言中至少有四种创建数组，这里就介绍四种常用的。 int [] nums = {1,3,5,7}; int [] a = new int []{1,2,3,4}; int [] a = new int [4]; //再添加 ArrayList<Integer> a = new ArrayList<>();//add添加元素 ②添加元素 a.add(9); 直接添加
代码随想录 LeetCode数组篇 长度最小的子数组
guliguliguliguli的博客
05-06 559
暴力法，最直观的方法。初始化子数组的最小长度为无穷大，枚举数据nums中的每个下标为子数组的开始下标，对于每个开始下标i，需要找到大于或等于i的最小下标j，使得从nums[i]到nums[j]的元素和大于等于target，并更新子数组的最小长度（此时子数组的最小长度是j-i+1）然后遍历字符串s，check()函数用来检验当前left到right的区间内的字符是否已经覆盖了字符串t，就是比较当arrt数组不为零的那些位置，arrs数组中的元素是否大于等于arrt数组中的那些位置，如果相等，则覆盖字符串t。
[C++学习] 数组 移除元素 代码随想录 LeetCode题 代码 笔记
qq_49696822的博客
01-22 812
每次让两指针逆序地遍历两字符串，直到两字符串能够各自确定一个字符，然后将这两个字符进行比较。，当快指针指向元素为退格字符‘#’，慢指针减一，deleteString 函数返回处理完退格信息的字符串。题目描述：原数组是有序的，则数组平方的最大值只可能出现在原数组的两端，定义一个新数组逆序保存原数组。（优化，避免了需要保留元素的重复赋值）：当左边的元素等于目标值时，用右边的元素覆盖。）：指针1 和 指针2 都从头到尾，方向相同，但。扫描：指针1从头到尾，指针2从尾到头，在中间汇合。三、 LeetCode题。
【leetcode刷题总结】——代码随想录（数组总结）
lingxw的博客
05-02 2297
按照数组-> 链表-> 哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->图论->高级数据结构，再从简单刷起，做了几个类型题目之后，再慢慢做中等题目、困难题目。
代码随想录_数组_leetcode27 移除元素
thh_1213的博客
03-16 51
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。输入：nums = [0,1,2,2,3,0,4,2], val = 2。元素的顺序可以改变。输入：nums = [3,2,2,3], val = 3。输出：5, nums = [0,1,4,0,3]
代码随想录数组篇——移除元素
qq_39473176的博客
09-01 93
刷题总结
《LeetCode力扣练习》代码随想录——数组（移除元素---Java）
XRT_knives的博客
11-01 96
《LeetCode力扣练习》代码随想录——数组（移除元素---Java）
leetcode数组中元素出现次数-LeetCode:力扣问题
06-30
leetcode数组中元素出现次数 LeetCode LeetCode Problems ()
leetcode数组下标大于间距-leetcode:leetcode刷题代码
06-30
设置一个map容器用来记录元素的索引和值之间的关系，遍历数组nums，设置临时变量来存储目标值与当前值的差值，在map寻找是否有与差值一致的值，如果没有的话，就在map中保存该元素和索引；如果查找成功就返回索引值...
leetcode数组下标大于间距-Leetcode:Leetcode做题记录
06-30
leetcode数组下标大于间距 Leetcode Leetcode做题记录 目前先从简单的开始做，慢慢提升 :) 已完成： 面试题 05.06. 整数转换 1 两数之和 3 无重复字符的最长子串 5 最长回文子串 7 整数反转 8 字符串转换整数 (atoi)...
leetcode数组中元素出现次数-leetcode-js:JS的LeetCode问题
06-30
leetcode数组中元素出现次数LeetCode-JS 最近更新 完成列表(444) # 标题 困难 1 简单的 2 中等的 3 中等的 4 难的 5 中等的 6 中等的 7 简单的 8 中等的 9 简单的 10 难的 11 中等的 12 中等的 13 简单的 14 简单的 ...
Leetcode40 无重复组合之和
最新发布
zjshuster的博客
06-25 512
给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。若不考虑重复，一个简单的思路是递归+回溯，要考虑去重, 一种有效做法是先排序，相同元素在同一条递归路径下只被选取一次，这样可以实现有效剪枝。candidates 中的每个数字在每个组合中只能使用 一次。这个题是leetcode39的延续。注意：解集不能包含重复的组合。
LeetCode：经典题之206、92 题解及延伸
Chiefavefan
06-22 1071
LeeCode经典题之206、92｜反转链表 I 和 II｜类与结构体｜访问修饰符
LeetCode118.杨辉三角 | LeetCode119.杨辉三角Ⅱ
iiiiiankor的博客
06-21 491
给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。每一次从当前行j位置开始，从后向前走（否则前面的会被覆盖）在「杨辉三角」中，每个数是它左上方和右上方的数的和。，返回「杨辉三角」的第。就从下标从1的行开始迭代。j位置+=j-1位置的值。求下标为index的行。
LeetCode.41缺失的第一个正数详解
LeoLei8060的博客
06-22 452
首先，遍历数组，对于每个元素，如果它是一个正整数并且它不在它的理想位置（例如数字 iii 应该位于索引i−1），则将它与其理想位置上的元素交换。最后，遍历数组查找第一个非负数的索引，该索引加 1 即为未出现的最小正整数。通过确保所有的正整数均在数组中有一个对应的索引，我们可以通过索引位置来判断一个数是否存在于数组中。再次遍历数组，第一个其索引+1不等于其值的位置，就指示了未出现的最小正整数。首先，我们需要遍历数组，将所有非正整数以及大于数组长度的数替换为一个大于数组长度的值（例如。请你实现时间复杂度为。
leetcode数组
06-07
其中数组是一种非常基础和常用的数据结构，它可以用来表示一组元素并支持常见的操作，如插入、删除、查找等。在LeetCode中，数组相关的题目也非常多，涉及到的知识点也比较广泛，例如排序、二分查找、滑动窗口、双...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值