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;
		
	}
}