代码随想录算法训练营第13天|239. 滑动窗口最大值 347. 前 K 个高频元素

54 篇文章 0 订阅
53 篇文章 0 订阅

239. 滑动窗口最大值

给你一个整数数组 nums,有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值

示例 1:

输入:nums = [1,3,-1,-3,5,3,6,7], k = 3
输出:[3,3,5,5,6,7]
解释:
滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

示例 2:

输入:nums = [1], k = 1
输出:[1]

提示:

  • 1 <= nums.length <= 105
  • -104 <= nums[i] <= 104
  • 1 <= k <= nums.length

教程:https://programmercarl.com/0239.%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E6%9C%80%E5%A4%A7%E5%80%BC.html

视频:https://www.bilibili.com/video/BV1XS4y1p7qj

方法一:暴力

思路:限定左右边界,每次计算边界中k个元素的最大值

复杂度分析

  • 时间复杂度: O ( n k ) O(nk) O(nk)

  • 空间复杂度: O ( n ) O(n) O(n)

import java.util.ArrayList;
import java.util.List;

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        List<Integer> result = new ArrayList<>();
        // int[] result = new int[nums.length];
        int left =0;
        int right = left+k-1;

        while(right<nums.length ){
            int max1 = Integer.MIN_VALUE;
            for(int i =left; i<=right;i++){
                max1= Math.max(max1, nums[i]);
            }
            result.add(max1);

            left++;
            right++;
        }
        //方法一:List<Integer> 转 int[]
        int[] arr = new int[result.size()];
        for (int i = 0; i < result.size(); i++) {
            arr[i] = result.get(i);
        }

        //方法二:List<Integer> 转 int[]
        // int[] arr = list.stream().mapToInt(i -> i).toArray();
        return arr;
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
//        int[] nums={1,3,-1,-3,5,3,6,7};
//        int[] nums={1,-1};
        int[] nums={1};
        int[] a= solution.maxSlidingWindow(nums,1);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
    }
}

在这里插入图片描述

leetcode上超出时间限制,虽然但是写出这个暴力也是磕磕绊绊,还需要debug。

方法二:单调队列

思路:利用双端队列手动实现单调队列

还是不太理解,和暴力基本一个思路,就是使用数据结构不一样,关于如何维护有序,不太理解,队列存的是nums的下标。

关于队头结点的下标范围,以例子int[] nums={1,3,-1,-3,5,3,6,7},k=3

i从0开始, nums.length-1结束,这个是用来遍历的,遍历nums的每个元素;

队头结点需要在[i - k + 1, i]范围内,也就是[i-2,i],那么i怎么也得是2的时候,这个范围才是正常的。方法一的思路是[i,i+k-1]。

补充:

ArrayDeque<Integer> 是 Java 中的一种双端队列(deque)数据结构,也被称为数组双端队列。它是使用数组实现的双端队列,可以在队列两端进行高效的插入和删除操作。和上次的Deque<Character>双端队列很像,

在这里插入图片描述

deque相关

  1. deque.peek(): 这个函数返回双端队列(即deque)的头部元素,但不会将其从队列中移除。在代码中,deque.peek()用于获取队列头部指针对应的值,即获取队列中最大元素的下标。
  2. deque.poll(): 这个函数从双端队列(即deque)的头部移除并返回一个元素。在代码中,deque.poll()用于移除队列头部指针对应的元素,即移除队列中的最大元素的下标。
  3. deque.peekLast(): 这个函数返回双端队列(即deque)的尾部元素,但不会将其从队列中移除。在代码中,deque.peekLast()用于获取队列尾部指针对应的值,即获取队列中当前窗口内的最大元素。
  4. deque.pollLast(): 这个函数从双端队列(即deque)的尾部移除并返回一个元素。在代码中,deque.pollLast()用于移除队列尾部指针对应的元素,即移除队列中当前窗口内的最大元素的下标。
  5. deque.offer(i): 这个函数将指定的元素插入双端队列(即deque)的尾部。在代码中,deque.offer(i)用于将当前元素的下标i插入到队列中,以维护一个单调递减的队列。这样可以确保队列中的元素按照从大到小的顺序排列。

复杂度分析

  • 时间复杂度: O ( n ) O(n) O(n)

  • 空间复杂度: O ( n ) O(n) O(n)

//解法二
//利用双端队列手动实现单调队列

import java.util.ArrayDeque;

/**
 * 用一个单调队列来存储对应的下标,每当窗口滑动的时候,直接取队列的头部指针对应的值放入结果集即可
 * 单调队列类似 (tail -->) 3 --> 2 --> 1 --> 0 (--> head) (右边为头结点,元素存的是下标)
 */
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        ArrayDeque<Integer> deque = new ArrayDeque<>();
        int n = nums.length;
        int[] res = new int[n - k + 1];
        int idx = 0;
        for(int i = 0; i < n; i++) {
            // 根据题意,i为nums下标,是要在[i - k + 1, i] 中选到最大值,只需要保证两点
            // 1.队列头结点需要在[i - k + 1, i]范围内,不符合则要弹出
            while(!deque.isEmpty() && deque.peek() < i - k + 1){//deque有值 且 deque头部元素小于有边界(就是在k范围内)
                deque.poll();//移除头部元素
            }
            // 2.既然是单调,就要保证每次放进去的数字要比末尾的都大,否则也弹出
            while(!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();//移除尾部元素
            }

            deque.offer(i);//将元素插入尾部

            // 因为单调,当i增长到符合第一个k范围的时候,每滑动一步都将队列头节点放入结果就行了
            if(i >= k - 1){
                res[idx++] = nums[deque.peek()];
            }
        }
        return res;
    }
    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] nums={1,3,-1,-3,5,3,6,7};
//        int[] nums={1,-1};
//        int[] nums={1};
        int[] a= solution.maxSlidingWindow(nums,3);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
    }
}

347. 前 K 个高频元素

给你一个整数数组 nums 和一个整数 k ,请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

示例 2:

输入: nums = [1], k = 1
输出: [1]

提示:

  • 1 <= nums.length <= 105
  • k 的取值范围是 [1, 数组中不相同的元素的个数]
  • 题目数据保证答案唯一,换句话说,数组中前 k 个高频元素的集合是唯一的

**进阶:**你所设计算法的时间复杂度 必须 优于 O(n log n) ,其中 n 是数组大小。

教程:https://programmercarl.com/0347.%E5%89%8DK%E4%B8%AA%E9%AB%98%E9%A2%91%E5%85%83%E7%B4%A0.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE

视频:https://www.bilibili.com/video/BV1Xg41167Lz/

方法一:基于大顶堆实现

思路:能想到map,但是不会写

347.前K个高频元素

复杂度分析

  • 时间复杂度: O ( l o g n ) O(logn) O(logn)

  • 空间复杂度: O ( l o g n ) O(logn) O(logn)

import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;

class Solution {
    public int[] topKFrequent(int[] nums, int k) {

        Map<Integer,Integer> map = new HashMap<>();//key为数组元素值,val为对应出现次数
        for(int num:nums){
            map.put(num,map.getOrDefault(num,0)+1);//map.getOrDefault(num,0):当map中存在num的键,则返回对应值,否则返回0;
        }
        //在优先队列中存储二元组(num,cnt),cnt表示元素值num在数组中的出现次数
        //出现次数按从队头到队尾的顺序是从大到小排,出现次数最多的在队头(相当于大顶堆)
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2)->pair2[1]-pair1[1]);
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){//大顶堆需要对所有元素进行排序
            pq.add(new int[]{entry.getKey(),entry.getValue()});
        }
        int[] ans = new int[k];
        for(int i=0;i<k;i++){//依次从队头弹出k个,就是出现频率前k高的元素
            ans[i] = pq.poll()[0];
        }
        return ans;
    }

    public static void main(String[] args) {
        int[] nums={1,1,1,2,2,3};
        Solution solution = new Solution();
        solution.topKFrequent(nums,3);
    }
}

补充:

map:
  1. map.getOrDefault(num,0):当map中存在num的键,则返回对应值,否则返回0;
  2. map.put(key,value)向map中添加键值对
  3. map.put(num,map.getOrDefault(num,0)+1);则统计了一个数组nums的出现数字的频率,频率作为value存进了map
PriorityQueue

PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2)->pair2[1]-pair1[1]);创建了一个int数组的优先队列PriorityQueue,并使用lambda表达式定义了一个比较器,用于根据数组中第二个元素的大小来比较两个元素。

参数 (pair1, pair2) -> pair2[1] - pair1[1] 表示一个比较器,该比较器定义了两个数组 pair1 和 pair2 的比较方式。具体规则是:如果 pair1 中第二个元素小于 pair2 中的第二个元素,则 pair2 大于 pair1,返回正数;如果 pair1 中第二个元素等于 pair2 中的第二个元素,则它们相等,返回0;如果 pair1 中第二个元素大于 pair2 中的第二个元素,则 pair1 大于 pair2,返回负数。

根据比较器的规则,优先队列中的元素会按照第二个元素的大小进行排序,即第二个元素越大的数组在队列中越靠前。这里可以理解为map的键,也就是元素出现的频次,从高到低。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
第二十二算法训练营主要涵盖了Leetcode题目中的三道题目,分别是Leetcode 28 "Find the Index of the First Occurrence in a String",Leetcode 977 "有序数组的平方",和Leetcode 209 "长度最小的子数组"。 首先是Leetcode 28题,题目要求在给定的字符串中找到第一个出现的字符的索引。思路是使用双指针来遍历字符串,一个指向字符串的开头,另一个指向字符串的结尾。通过比较两个指针所指向的字符是否相等来判断是否找到了第一个出现的字符。具体实现的代码如下: ```python def findIndex(self, s: str) -> int: left = 0 right = len(s) - 1 while left <= right: if s[left == s[right]: return left left += 1 right -= 1 return -1 ``` 接下来是Leetcode 977题,题目要求对给定的有序数组中的元素进行平方,并按照非递减的顺序返回结果。这里由于数组已经是有序的,所以可以使用双指针的方法来解决问题。一个指针指向数组的开头,另一个指针指向数组的末尾。通过比较两个指针所指向的元素的绝对值的大小来确定哪个元素的平方应该放在结果数组的末尾。具体实现的代码如下: ```python def sortedSquares(self, nums: List[int]) -> List[int]: left = 0 right = len(nums) - 1 ans = [] while left <= right: if abs(nums[left]) >= abs(nums[right]): ans.append(nums[left ** 2) left += 1 else: ans.append(nums[right ** 2) right -= 1 return ans[::-1] ``` 最后是Leetcode 209题,题目要求在给定的数组中找到长度最小的子数组,使得子数组的和大于等于给定的目标值。这里可以使用滑动窗口的方法来解决问题。使用两个指针来表示滑动窗口的左边界和右边界,通过移动指针来调整滑动窗口的大小,使得滑动窗口中的元素的和满足题目要求。具体实现的代码如下: ```python def minSubArrayLen(self, target: int, nums: List[int]) -> int: left = 0 right = 0 ans = float('inf') total = 0 while right < len(nums): total += nums[right] while total >= target: ans = min(ans, right - left + 1) total -= nums[left] left += 1 right += 1 return ans if ans != float('inf') else 0 ``` 以上就是第二十二算法训练营的内容。通过这些题目的练习,可以提升对双指针和滑动窗口算法的理解和应用能力。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Catherinemin

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值