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

 解法一：

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

时间复杂度：n方

class Solution {
    public int removeElement(int[] nums, int val) {
        int size=nums.length;
        for(int i=0;i

解法二：

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

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

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

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

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

class Solution {
    public int removeElement(int[] nums, int val) {
     int slow=0;
     for(int fast=0;fast

解法：

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

class Solution {
    public int removeDuplicates(int[] nums) {
        int slow=0;
        for(int fast=1;fast

解法：

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

class Solution {
    public void moveZeroes(int[] nums) {
        int slow=0;
        int count=nums.length;
        for(int quick=0;quick

解法：

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

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

​​​​​​​

class Solution {
    public int[] sortedSquares(int[] nums) {
        int slow=0;
        for(int fast=0;fast