算法刷题日志——移除元素，双指针

删除有序数组中的重复项

参考了三叶姐的通用解法
for（int x :nums) for的增强循环，x就是代表数组元素，k代表的是最多能保留的位数
由于是保留 k 个相同数字，对于前 k 个数字，我们可以直接保留。
对于后面的任意数字，能够保留的前提是：与当前写入的位置前面的第 k 个元素进行比较，不相同则保留。

class Solution {
    public int removeDuplicates(int[] nums) {
        return  process(nums,1);
    }
 int process(int[] nums,int k){
        int idx=0;
        for(int x:nums){
            if(idx< k || nums[idx-k]!=x)nums[idx++]=x;
        }
        return idx;
    }
}

删除有序数组中的重复项 II

和上题类似，把k改成2即可

class Solution {
    public int removeDuplicates(int[] nums) {
        return process(nums,2);

    }
    int process(int[]nums,int k){
        int idx=0;
        for(int x:nums){
            if(idx<k||nums[idx-k]!=x){
                nums[idx++]=x;
            }
        }
        return idx;
    }
}

移除元素

class Solution {
    public int removeElement(int[] nums, int val) {
            int idx= 0;
            for(int x:nums){
                if(x!=val)nums[idx++]=x;
            }
            return idx;
    }
}

283. 移动零

双指针遍历，第一次先把所有非0元素提前，然后后面从j位置开始全部变成0。

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

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

    }
}

844. 比较含退格的字符串

同时从后向前遍历S和T（i初始为S末尾，j初始为T末尾），记录#的数量，模拟消除的操作，如果#用完了，就开始比较S[i]和S[j]。

class Solution {
    public boolean backspaceCompare(String s, String t) {
            int sCount = 0;
            int tCount = 0;
            int i = s.length()-1;
            int j = t.length()-1;
            char[] ss = s.toCharArray();
            char[] tt = t.toCharArray();
            while(true){
                while(i>=0){
                    if(ss[i]=='#'){
                        sCount++;

                    }else{
                        if(sCount>0)sCount--;
                        else{
                            break;
                        }
                    }
                    i--;
                }
                while(j>=0){
                    if(tt[j] =='#' ){
                        tCount++;
                    }else{
                        if(tCount>0)tCount--;
                        else{
                            break;
                        }
                    }
                    j--;

                }
                if(i<0||j<0)break;
                if(ss[i]!=tt[j])return false;
                i--;j--;

            }
            if(i==-1&&j==-1)return true;
            return false;
    }
}

977. 有序数组的平方

双指针算法

class Solution {
    public int[] sortedSquares(int[] nums) {
            int n = nums.length;
            int i = n-1;
            int l=0,r=n-1;
            int []ans = new int [n];
            while(l<=r){
                if(nums[l]*nums[l]>nums[r]*nums[r]){
                    ans[i--]=nums[l]*nums[l++];
                }
                else{
                    ans[i--]=nums[r]*nums[r--];
                }

            }
            return ans;
    }
}