代码随想录算法训练营第三十一天| day 1 复习 & 贪心算法

RicardoLee7

已于 2023-04-15 14:07:34 修改

阅读量97

点赞数

文章标签：算法 leetcode 数据结构

于 2023-04-14 09:00:24 首次发布

本文链接：https://blog.csdn.net/weixin_44418954/article/details/130144465

版权

704. 二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/binary-search
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int search(int[] nums, int target) {
        return binarySearch(nums,target,0,nums.length-1);
    }

    private int binarySearch(int [] nums, int target, int left, int right){
        if(left>right){
            return -1;
        }
        int mid = left + (right-left)/2;
        if(nums[mid]==target){
            return mid;
        }else if(nums[mid]>target){
            return binarySearch(nums,target,left,mid-1);
        }else{
            return binarySearch(nums,target,mid+1,right);
        }
    }
}

这次用迭代做

27. 移除元素

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/remove-element
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int removeElement(int[] nums, int val) {
        int slow =0;
        for(int fast =0; fast<nums.length;fast++){
            if(nums[fast]!=val){
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }
}

快慢指针

26. 删除有序数组中的重复项

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

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。

不要使用额外的空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

判题标准:

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/remove-duplicates-from-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int removeDuplicates(int[] nums) {
        // 从1开始因为第一个元素肯定要保留
        int slow = 1;
        for(int fast=1;fast<nums.length;fast++){
            // 只保留不重复的
            if(nums[fast]!=nums[fast-1]){
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }
}

283. 移动零

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

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

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

slow指针表示已处理好的列表的尾部

fast指针表示未处理的列表的头部

844. 比较含退格的字符串

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

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/backspace-string-compare
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public boolean backspaceCompare(String s, String t) {
        String s2 = process(s);
        String t2 = process(t);
        return s2.equals(t2);
    }

    private String process(String s){
        int skip = 0;
        StringBuilder sb = new StringBuilder();
        for(int i=s.length()-1;i>=0;i--){
            if(s.charAt(i)=='#'){
                skip++;
            }else{
                if(skip!=0){
                    skip--;
                }else{
                    sb.append(s.charAt(i));
                }
            }
        }
        return sb.reverse().toString();
    }
}

977.有序数组的平方

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

class Solution {
    public int[] sortedSquares(int[] nums) {
        int left = 0;
        int right = nums.length-1;
        int [] res = new int [nums.length];
        int index = nums.length-1;
        while(left<=right){
            if(nums[left]*nums[left]>=nums[right]*nums[right]){
                res[index] = nums[left]*nums[left];
                left++;
            } else{
                res[index] = nums[right]*nums[right];
                right--;
            }
            index--;
        }
        return res;
    }
}

双指针，从两边到中间。res数组从后到前逆向构建，因为res需要是一个递增数组。每次选较大的放在res数组中

贪心算法

455. 分发饼干

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/assign-cookies
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int res =0 ;
        int index = s.length-1;
        for(int i=g.length-1;i>=0;i--){
            if(index>=0 && g[i]<=s[index]){
                index--;
                res++;
            }
        }
        return res;
    }
}

局部最优解是大饼干喂给胃口大的。全局最优解是喂饱尽可能多的小孩

376. 摆动序列

如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。

例如， [1, 7, 4, 9, 2, 5] 是一个摆动序列，因为差值 (6, -3, 5, -7, 3) 是正负交替出现的。

相反，[1, 4, 7, 2, 5] 和 [1, 7, 4, 5, 5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
子序列可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。

给你一个整数数组 nums ，返回 nums 中作为摆动序列的最长子序列的长度。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/wiggle-subsequence
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int wiggleMaxLength(int[] nums) {
        if(nums.length <=1){
            return nums.length;
        }

        // 当前差值
        int currDiff = 0;
        // 上一个差值
        int preDiff = 0;
        int count = 1;
        for(int i=1;i<nums.length;i++){
            // 得到当前差值
            currDiff = nums[i] - nums[i-1];
            // 如果当前差值和上一个差值为一正一负
            // 等于0的情况表示初始时的preDiff
            if((currDiff>0 && preDiff<=0)|| (currDiff <0 && preDiff >=0)){
                count ++;
                preDiff = currDiff;
            }
        }
        return count;
    }
}

遇到单调序列不需要删除，因为我们求得是序列数量。

比如 1 2 3 4： count只增加一次是二

局部最优：删除单调坡度上的节点（不包括单调坡度两端的节点），那么这个坡度就可以有两个局部峰值。整体最优：整个序列有最多的局部峰值，从而达到最长摆动序列。

53. 最大子数组和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

class Solution {
    public int maxSubArray(int[] nums) {
        int res = Integer.MIN_VALUE;
        int temp = 0;
        for(int i=0;i<nums.length;i++){
            temp +=nums[i];
            // 更新res
            if(temp>res){
                res = temp;
            }
            // <=0重新开始
            if(temp<=0){
                temp = 0;
            }
        }
        return res;
    }
}

局部最优：当连续和为负数时立即放弃，从下一个元素重新开始，因为负数会导致连续和越来越小

全局最优：选取最大的连续和

RicardoLee7

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第三十一天| day 1 复习 & 贪心算法

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。给你一个升序排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
复制链接

扫一扫