代码随想录算法刷题训练营day13

代码随想录算法刷题训练营day13：LeetCode(239)滑动窗口最大值、LeetCode(347)前 K 个高频元素

LeetCode(239)滑动窗口最大值
题目

代码

import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        myQueue myQueue1=new myQueue();
        //使用双端队列去做
        int len=nums.length;
        if(len==1){
            return nums;//返回这个数组，去除边角料的情况
        }
        int len1=len-k+1;//返回数组的长度
        int[] result=new int[len1];
        int numbers=0;
        //先把第一个滑动窗口的数据，把它扔进去
        for(int i=0;i<k;i++){
            myQueue1.mypush(nums[i]);
        }
        result[numbers++]=myQueue1.getMax();
        for(int j=k;j<nums.length;j++){
            int tempdata=nums[j-k];//先移-再加
            myQueue1.mypop(tempdata);
            myQueue1.mypush(nums[j]);
            result[numbers++]=myQueue1.getMax();    
        }
        return result;


    }
}
//首先得定义一个双端队列
class myQueue{
    public myQueue(){
        //定义一个双端队列
    }
    Deque<Integer> myDeque=new LinkedList<>();//队列
    //这个队列是由队列进行改编的
    
    /* 
     * 提供三个方法
     * 1、添加元素
     * 2、取最大元素
     * 3、删除元素
     */
    //1、添加元素
    public void mypush(int val){
        
        while(myDeque.isEmpty()==false&&val>myDeque.getLast()){
            myDeque.removeLast();//将最后一个元素移除，你需要连续移除，所以需要连续比较
        }
        myDeque.add(val);//push与add不一样，队列用add，栈用push
        }
    //2、弹出元素----根据元素值弹出元素
    public void mypop(int val){
        if(!myDeque.isEmpty()&&val==myDeque.peek()){
            myDeque.poll();
        }
    }
    //3、取最大值
    public int getMax(){
        return myDeque.peek();
    }

LeetCode(347)前 K 个高频元素
题目

代码

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



class Solution {
    public int[] topKFrequent(int[] nums, int k) {
       //定义一个Map数组，用于存储每个数字出现的次数
       Map<Integer,Integer> map=new HashMap<>();
       for(int i=0;i<nums.length;i++){
        if(map.containsKey(nums[i])){
            map.put(nums[i],map.get(nums[i])+1);
        }else{
            map.put(nums[i],1);
        }
       }
       //把数据存储完成之后，构建小顶椎，小顶椎每次弹出的元素是最小的，可以保留次数最大的
       PriorityQueue<int[]> small=new PriorityQueue<>((a,b)->a[1]-b[1]);//括号里面定义比较规则
       int number=0;//定义一个记录元素数量值
       Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
       for(Map.Entry<Integer, Integer> entry:entries){
        if(number<k){
            small.add(new int[]{entry.getKey(),entry.getValue()});
        }else{
            int[] tempdata=small.peek();
            if(entry.getValue()>tempdata[1]){
                small.poll();//把头顶干掉
                small.add(new int[]{entry.getKey(),entry.getValue()});
            }
        }
        number++;  
       }
       //此时堆里面仅有k个元素
       int[] result=new int[k];
       for(int i=k-1;i>=0;i--){
        result[i]=small.poll()[0];
       }
       return result;

    }
}