算法-数组-移除元素

	我们在上一节讲过了，数组的地址是连续的，我们不可能像集合那样去删除某个元素，只能进行覆盖。那么我们首先想到的就是每次找到这个元素的是，就将这个元素的后面的所有的元素都是向前移动一位，这样就实现了元素的移动，但是现在我们有了新的方式来移动这些元素，就是每遍历这个元素的时候，就做一个判断，只有当这个元素符合条件的时候，我们才会将其移除掉。

下面我们来看一道例题：
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 $O(1)$ 额外空间并原地修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。
示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
你不需要考虑数组中超出新长度后面的元素。
数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。
使用两层for循环也是可以解决问题的，但是时间复杂度太高了，这里可以使用如下的方式来进行代码优化，代码如下：

class Solution {
    public int removeElement(int[] nums, int val) {
        int count = 0;
        for(int i = 0;i < nums.length;i++){
            if(nums[i] != val){
                //相当于将后面的不等于val的数据向前移动一位（实际上是覆盖掉）
                //在这个题目中，就是将第一个2覆盖掉第一个3，然后将第二个2覆盖掉原来的第一个2的位置，最后返回数组的前两个，那么前两个就是都是2了，后面的2和3就不管了，这样就相当于数组的移动了
                nums[count++] = nums[i];
            }
        }
        return count;
    }
}

另外一种方法，使用快慢指针的方法

class Solution {
    public int removeElement(int[] nums, int val) {
        // 快慢指针
        int fastIndex = 0;
        int slowIndex;
        for (slowIndex = 0; fastIndex < nums.length; fastIndex++) {
            if (nums[fastIndex] != val) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
}

上面的两个方法都是使用的部分移动的方法，而不是每一次找到这个元素，后面都是会移动所有的元素。
下面我们来看一下与这道题相似的题目：
第一题：给你一个升序排列的数组nums，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持一致。将最终结果插入nums的前 k个位置后返回k不要使用额外的空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

class Solution {
    public int removeDuplicates(int[] nums) {
        int count = 0;
        for(int i = 0;i < nums.length;i++){
            if(nums[i] != nums[count]){
                //这里表示的是如果指针i指向的数和指针count指向的数不一样，就表示遇到了不同的数，这样就需要将这个不同的数向前移动，但是这里需要注意的是移动的位置必须是count的后面一个，不然前面的那个数将会被覆盖，这样的话，就不是移动数据了，最后得到的结果只会是后面的数据，而且后面的数据将会有很多的重复的
                nums[++count] = nums[i];
            }
        }
        //这里需要先将count加一以后再返回，这是因为count是从零开始计算的，所以真正的数据的个数是count(索引)的值后面再加一个
        return ++count;
    }
}

第二题：给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。请注意 ，必须在不复制数组的情况下原地对数组进行操作。
分析：将所有的值不等于0的数据向前移，然后将后面的数全部改成0即可，这里也是涉及到数组中数据的移动。

class Solution {
    public void moveZeroes(int[] nums) {
        int count = 0;
        //第一个for循环，就是将所有的非零的元素向前移动
        for(int i = 0;i < nums.length;i++){
            if(nums[i] != 0){
                nums[count++] = nums[i];
            }
        }
        //第二个for循环，就是将后面的元素改为零，这样就相当于将所有的0移动到数组的尾部了
        for(int i = count;i <nums.length;i++){
            nums[i] = 0;
        }
    }
}

第三题：给定s和t两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回true 。#代表退格字符。注意：如果对空 文本输入退格字符，文本继续为空。
分析：遍历这个字符串，当不是#的时候，我们就将它加到StringBuffer中去，如果遇到了#，那么我们就将StringBuffer中的最后一个字符删除掉就可以了。

class Solution {
    public boolean backspaceCompare(String s, String t) {
        return build(s).equals(build(t));
    }
    //定义一个方法，让它返回在经过处理以后的字符串
    public String build(String str){
        StringBuffer stringBuffer = new StringBuffer();
        for(int i = 0;i < str.length();i++){
            char ch = str.charAt(i);
            //如果当前的字符不是等于“#”的话，那么就将它加到这个stringBuffer字符串中
            if(ch != '#'){
                stringBuffer.append(ch);
            }else{
                //如果当前字符是等于“#”的话，那么还需要判断当前的stringBuffer字符串是否魏空，如果不是为空的话，就删除掉最后一个字符，如果是为空的话，那么就不需要去改动这个字符串
                if(stringBuffer.length() > 0){
                    stringBuffer.deleteCharAt(stringBuffer.length()-1);
                }
            }
        }
        return stringBuffer.toString();
    }
}

第四题：给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。
分析：最先想到的就是将这个数组平方以后再排序，代码如下：

class Solution {
    public int[] sortedSquares(int[] nums) {
        for(int i = 0;i< nums.length;i++){
            nums[i] = nums[i] * nums[i];
        }
        Arrays.sort(nums);
        return nums;
    }
}

当然，这道题还有另外的一种方法，就是在平方了以后大的数据肯定是左边的或者是有变的，肯定不是中间的，这样的话，只需要将左边的数据的平方和右边的数据的平方做一个比较，然后将大的数据放到新创建的那个数组中去（但是一定是从后往前面放，这样才能保证小的数据在前面，大的数据在后面）

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] array = new int[nums.length];
        int left = 0;//左指针指向开头
        int right = nums.length - 1;//右指针指向结尾
        int index = array.length - 1;//放元素的起始位置就是末尾，从后面往前面放
        while(left <= right){
            if(nums[left] * nums[left] <= nums[right] * nums[right]){
                array[index--] = nums[right] * nums[right];
                right--;
            }else{
                array[index--] = nums[left] * nums[left];
                left++;
            }
        }
        return array;
    }
}

以上是我根据代码随想录学习算法的思考，如有错误或者侵权的地方，请联系我改正或者删除。欢迎大家和我一起探讨关于java和算法的知识。