力扣-数组-移除元素-双指针

 解法一：

暴力破解，设置两层循环，每找到一个符合条件的元素就进入深层循环，将所有的元素都往前走一位覆盖掉原来的元素，并且将有效长度size--，将遍历索引i--（因为你需要从覆盖掉的那个元素位置开始判断）。

时间复杂度：n方

class Solution {
    public int removeElement(int[] nums, int val) {
        int size=nums.length;
        for(int i=0;i<size;i++){
            if(nums[i]==val){
                for(int j=i+1;j<size;j++){
                    nums[j-1]=nums[j];//覆盖过后的数组向前移动，但是整个长度还是没变，但是确实多做了一些无用判断，最后返回长度。因为num是引用方式调用的所以，你修改数组，数组就被真正的修改了。
               }
               size--;//记录的长度变短
               i--;//一位被移除了，下一位被覆盖了，需要从这个位置进行重新判断
            } 
        }
        return size;
    }
}

解法二：

双指针法：通过两个指针在一个for循环下完成两个for循环的操作。

简单来说就是慢指针追快指针。快指针用来作为判断，慢指针用来作为输入位置。

快指针++，慢指针跟随++，快指针判断此处位置是否是目标val，不是的话就继续走。

如果快指针找到和val相同的数值，此时慢指针指向到了val的位置停下来，快指针继续走寻找到一个不等于val的值赋值给慢指针所在位置。

重复此操作指导遍历完整个数组。

class Solution {
    public int removeElement(int[] nums, int val) {
     int slow=0;
     for(int fast=0;fast<nums.length;fast++){
         if(val!=nums[fast]){
             //如果不相等，让fast指针一步步走的时候slow跟随，把fast的数值给slow。
             //如果相等slow的位置不动，fast继续向前走，找到不相等的去赋值
             //最后可以把所有所有等于val的排除掉
             nums[slow]=nums[fast];
             slow++;
         }
     }
     return slow;
    }
}

解法：

和上题类似，但是多了一个重复项判断的内容，因此需要改变指针的位置，即第零个元素必存在， 用第一个元素和他判断并赋值在（零+1）位置上，因为慢指针赋值完的元素不再对其进行操作。这样依次对比判断得到最终结果。

class Solution {
    public int removeDuplicates(int[] nums) {
        int slow=0;
        for(int fast=1;fast<nums.length;fast++){
            //将第1指针和第0指针进行判断，总是让快指针至少比慢指针快一个
            //并且替换慢指针前面那个元素，因为慢指针指向的元素都是必定不重复的内容，不可以改变。
            if(nums[slow]!=nums[fast]){
                nums[slow+1]=nums[fast];
                slow++;
            }
        }
        return slow+1;//赋值的位置总是慢指针+1的位置，因此最后需要返回的数组索引为慢指针+1.
    }
}

解法：

和最传统的移除数组相同，只是多了一个将所有等于0的元素移到数组的最后去，那么我们只要正常的利用双指针进行移除，在移除的过程中统计含零元素的数量，随后将结尾的元素赋值为零就完成了。

class Solution {
    public void moveZeroes(int[] nums) {
        int slow=0;
        int count=nums.length;
        for(int quick=0;quick<nums.length;quick++){
            if(nums[quick]!=0){
                nums[slow]=nums[quick];
                slow++;
                count--;
            }
            
        }
        for(int i=nums.length-count;i<nums.length;i++){
            nums[i]=0;
        }
    }
}

解法：

贼恶心，用了三个小时，同时解法的时间复杂度和空间复杂度都比较高，待博主仔细思索再修改。

class Solution {
    public boolean backspaceCompare(String s, String t) {
        char[] s1=change(s);
        char[] t1=change(t);
        String s2=new String(s1);
        String t2=new String(t1);
        int l1=s1.length;
        int l2=t1.length;
        if(l1!=l2){
            String add2=add(s2,t2);
            if(s2.equals(add2)||t2.equals(add2)){
                return true;
            }else{
            return false;
            } 
        }else{
            if(s2.equals(t2)){
                return true;
            }else {
                return false;
            }
        }
       
    }
    //退位
     public static char[] change(String x) {
        char[] chs = x.toCharArray();
        int slow = 0;
        boolean flag = true;
        for (int quick = 1; quick < chs.length; quick++) {

            if (chs[quick] != '#') {
                if (flag == true) {
                    chs[slow + 1] = chs[quick];
                    if (slow < chs.length) {
                        slow++;
                    }
                } else {
                    slow = quick;
                }
                flag = true;
            } else {
                flag = false;
                chs[slow] = '#';
                if (slow == 0) {
                    slow = quick - 1;
                } else {
                    while (true){
                        if(chs[slow]=='#'){
                            if(slow==0){
                                break;
                            }
                                slow--;
                        }else {
                            break;
                        }
                    }


                    }


                }


            }

            int slow1 = 0;
            int count = chs.length;
            for (int fast = 0; fast < chs.length; fast++) {
                if (chs[fast] != '#') {

                    chs[slow1] = chs[fast];
                    slow1++;
                    count--;
                }
            }

            for (int i = chs.length - count; i < chs.length; i++) {
                chs[i] = '#';
            }

            return chs;
    }
    //补位
    public static String add(String str1,String str2){
        StringBuilder sb1=new StringBuilder(str1);
        StringBuilder sb2=new StringBuilder(str2);
        int l1=str1.length();
        int l2=str2.length();
        if(str1.length()>str2.length()){
            for(;l2<l1;l2++){
                sb2.append("#");
            }
            return sb2.toString();
        }else{
            for(;l1<l2;l1++)
                sb1.append("#");
        }
        return sb1.toString();
    }
}

​​​​​​​

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