Leetcode——703数据流中的第K个大元素、237滑动窗口最大值

优先队列：PriorityQueue
正常入，按优先级出
实现机制：
1.Heap(Binary,Binomial,Fibonacci)
2.Binary Search Tree

703.数据流中的第K个大元素
设计一个找到数据流中第K大元素的类（class）。注意是排序后的第K大元素，不是第K个不同的元素。

你的 KthLargest 类需要一个同时接收整数 k 和整数数组nums 的构造器，它包含数据流中的初始元素。每次调用 KthLargest.add，返回当前数据流中第K大的元素。
示例：

int k = 3;
int[] arr = [4,5,8,2];
KthLargest kthLargest = new KthLargest(3, arr);
kthLargest.add(3);   // returns 4
kthLargest.add(5);   // returns 5
kthLargest.add(10);  // returns 5
kthLargest.add(9);   // returns 8
kthLargest.add(4);   // returns 8

【思路】
传统思路：
把数据流中的数字存入k个大小的数组中，再按照从小到大排序，数据流中的数字再进入时，和数组的最小元素进行比较，要是比最小元素小的话，就不进入该数组，要是大的话进入数组，重新进行排序。时间复杂度：O（KlogK）快速排序
优先队列思路：
和传统思路类似，区别在于设置一个k大小的优先队列，该队列默认为小顶堆。该堆的顶为k个元素的最小值。大于该最小值就进入该堆进行重新排序，否则不进入该堆。时间复杂度为O（logk）。
【实现代码】

class KthLargest {
    final PriorityQueue<Integer> q;
    final int k;

    public KthLargest(int k, int[] nums) {
        this.k=k;
        q=new PriorityQueue<>(k);
        for(int n:nums)
            add(n);
    }
    
    public int add(int val) {
        if(q.size()<k)
            q.offer(val);
        else if (q.peek()<val){
            q.poll();
            q.offer(val);
        }
        return q.peek();
    }
}

/**
 * Your KthLargest object will be instantiated and called as such:
 * KthLargest obj = new KthLargest(k, nums);
 * int param_1 = obj.add(val);
 */

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

返回滑动窗口最大值

示例

输入: 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

注意：

你可以假设 k 总是有效的，1 ≤ k ≤ 输入数组的大小，且输入数组不为空。
【思路】
1.第一种思路是还是按照之前的优先队列，但是这里需要设置一个大顶堆，这个大顶堆的大小为k，随着滑动窗口的移动，假如新加入的元素大于堆顶元素则进入该堆，将堆顶元素弹出。同时还需要将超出滑动窗口大小的数据元素从堆中弹出。
2.使用双向队列来实现该滑动窗口的过程。
参考链接https://blog.csdn.net/top_code/article/details/8650729
【实现代码】

package leetcode_50;

import java.util.List;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Leetcode_239 {

	
	
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		String str=sc.nextLine();
		String[] s=str.split(",");
		int k=sc.nextInt();
		int[] result={};
		int[] a=new int[s.length];
		for(int i=0;i<a.length;i++) {
			a[i]=Integer.parseInt(s[i]);
			//System.out.print(a[i]+" ");
		}
		result=maxSlidingWindow(a,k);
		for(int n=0;n<result.length;n++){
			System.out.print(result[n]+" ");
		}
	}

	private static int[] maxSlidingWindow(int[] nums, int k) {
		if(nums.length==0) return new int[] {};
		//结果集
		List<Integer> res=new ArrayList<>();
		//双向队列保存的是索引值
		ArrayDeque<Integer> deq=new ArrayDeque<>();
		for(int i=0;i<nums.length;i++){
			//当随着滑动窗口的移动，左边的数组元素超出滑动窗口边界
			//则删除
			if(i>=k&&deq.getFirst()<=i-k)
				deq.pollFirst();
			while(!deq.isEmpty()&&nums[deq.peekLast()]<=nums[i]){
				deq.pollLast();
			
			}
			deq.add(i);
			//始终保持最左端是最大值
			if(i>=k-1){
				res.add(nums[deq.peekFirst()]);
			}
		}
		int size=res.size();
		int[] r=new int[size];
		for(int j=0;j<size;j++){
			r[j]=res.get(j);
		}
		return r;
		
	}
}