暑假算法刷题日记 Day 7

mjh_yylx

于 2024-08-08 14:02:53 发布

阅读量378

点赞数 12

文章标签：算法

本文链接：https://blog.csdn.net/gdjdjdj/article/details/141023890

版权

今天我们刷的题目主要是针对双指针的一些题目。主要有快慢指针，左右指针。话不多说上题

028 、移除元素

题目描述

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
返回 k。

解题思路

常规思路是两层for循环解决，遍历数组元素，是val我们就执行数组循环左移，将其覆盖。但是时间复杂度有点高，我们选择双指针将for循环将为一层。具体思路是快慢指针，快指针用于遍历数组，慢指针用于标记有效的元素。具体请看代码

代码

class Solution {
    public int removeElement(int[] nums, int val) {
        int l=0,r=0;
        int len = nums.length;
        while(r<len){
            if(nums[r]!=val){
            	//如果当前元素不是val，执行赋值，l和r同时向后
                nums[l++]=nums[r++];
            }else{
            	//如果是val，r向后
                r++;
            }
        }
        return l;
    }
}

029 、删除有序数组中的重复项

题目描述

给你一个非严格递增排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持一致。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
返回 k 。

解题思路

常规思路是两层for循环解决，遍历数组元素，是重复项我们就执行数组循环左移，将其覆盖。但是时间复杂度有点高O(n²)，我们选择双指针将for循环将为一层。具体思路是快慢指针，快指针用于遍历数组，慢指针用于标记有效的元素。具体请看代码

代码

class Solution {
    public int removeDuplicates(int[] nums) {
        int l=1,r=1;
        int len = nums.length;
        if(len==0)return 0;
        while(r<len){
        	//如果右指针和和前一项不同，则执行赋值操作，l和r同时向后
            if(nums[r]!=nums[r-1]){
                nums[l++]=nums[r++];
            }else r++;//否则只有r向后
        }
        return l;
    }
}

030 、移动零

题目描述

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意，必须在不复制数组的情况下原地对数组进行操作。

解题思路

代码

class Solution {
    public void moveZeroes(int[] nums) {
        int l=0,r=0;
        int len = nums.length;
        while(r<len){
            if(nums[r]==0){
                r++;
            }else{
                int temp=nums[r];
                nums[r]=nums[l];
                nums[l]=temp;
                l++;
                r++;
            }
        }

    }
}

亮点

我们发现这三个题的思路是很相似的，对于遍历到目标元素前两题的解决办法是覆盖，而这一个题是交换，把目标元素都移到后面去
其实这个思路还可以解决把正数和负数分到数组的两边去

031 、比较含退格的字符串

题目描述

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

注意：如果对空文本输入退格字符，文本继续为空。

解题思路

常规思路是对于含退格的string我们就把它删去，但是数组的删除操作复杂度是比较高的。我们用双指针来实现了一种O(n)的解决方案。我们的倒序比较两个字符串，每次拿到两个字符串中的有效字符进行比较，直至出现不同或者比较完成。
我们是如何拿到有效字符的呢？我们用一个变量delnum记录需要删除的字符数，每读到一个字符，如果是#，那么delnum++，如果不是#并且delnum>0，说明这个字符应该被删去，则delnum–，如果不是#并且delnum=0，说明此时拿到了有效的字符。接下来进行比较即可，需要注意一些极端情况。

代码

class Solution {
    public boolean backspaceCompare(String s, String t) {
        int p1=s.length()-1,p2=t.length()-1;
        while(p1>=0||p2>=0){//必须是||，否则会出问题
            int detNum1=0;
            while(p1>=0){
                if(s.charAt(p1)=='#'){
                    detNum1++;
                    p1--;
                }else if(detNum1>0){
                    p1--;
                    detNum1--;
                }else{
                    //拿到了比较对象
                    break;
                }
            }
            int detNum2=0;
            while(p2>=0){
                if(t.charAt(p2)=='#'){
                    detNum2++;
                    p2--;
                }else if(detNum2>0){
                    p2--;
                    detNum2--;
                }else{
                    //拿到了比较对象
                    break;
                }
            }
            //此时说明都拿到了比较对象
            if(p1>=0&&p2>=0){
                if(s.charAt(p1)!=t.charAt(p2))return false;
			//此时至少有一方没拿到比较对象
            }else{
                //如果只用一方没拿到比较对象，说明两个字符串有效长度不同，false
                if(p1>=0||p2>=0)return false;
            }
            p1--;p2--;
        }
        return true;
    }
}

032 、有序数组的平方

题目描述

给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

解题思路

我的思路是先找到绝对值最小的元素，然后向左右遍历，依次把平方小的加入数组。（法一）
看了答案的双指针思路感到更加巧妙，采用首位指针，依次把平方大的倒序加入数组。（法二）

代码

方法一

class Solution {
    public int[] sortedSquares(int[] nums) {
        
        int ptr=1;
        int len = nums.length;
        if(len==1)return new int[] {nums[0]*nums[0]};
        while(ptr<len){
            if(Math.abs(nums[ptr])-Math.abs(nums[ptr-1])>0){
                break;
            }
            ptr++;
        }
        
        int l=ptr-1,r=ptr;
        int size=0;
        int[] ans=new int[len];
        while(size<len&&l>=0&&r<len){
            if(Math.pow(nums[l],2)<=Math.pow(nums[r],2)){
                ans[size++]=(int)Math.pow(nums[l--],2);
            }else{
                ans[size++]=(int)Math.pow(nums[r++],2);
            }
            
        }
        while(size<len&&l>=0){
            ans[size++]=(int)Math.pow(nums[l--],2);
        }
        while(size<len&&r<len){
            ans[size++]=(int)Math.pow(nums[r++],2);
        }
        return ans;
    }
}

方法二

class Solution {
    public int[] sortedSquares(int[] nums) {
        int l=0,r=nums.length-1;
        int[] ans = new int[r+1];
        int ptr=r;
        while(l!=r){
            if(Math.pow(nums[l],2)>Math.pow(nums[r],2)){
                ans[ptr--]=(int)Math.pow(nums[l++],2);
            }else{
                ans[ptr--]=(int)Math.pow(nums[r--],2);
            }
        }
        ans[ptr]=(int)Math.pow(nums[l],2);
        return ans;
    }
}