剑指offer_滑动窗口的最大值

/*
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。
例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，
他们的最大值分别为{4,4,6,6,6,5}；
针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个：
{[2,3,4],2,6,2,5,1}，
{2,[3,4,2],6,2,5,1}，
{2,3,[4,2,6],2,5,1}，
{2,3,4,[2,6,2],5,1}，
{2,3,4,2,[6,2,5],1}，
{2,3,4,2,6,[2,5,1]}。

//直接思路
先求滑动窗口，再求最大值
遍历数组，将每个元素开头的size个元素中求最大元素
size过大可以，不影响，但size<=0不可以
O(nk)，k为窗口大小

剑指offer思路1：
用队列做滑动窗口，每滑动一次，队列头部删除一个元素，尾部添加一个元素
队列如果能满足在O(1)时间返回最大值，则整个只需要O(n)
这样的队列可以用两个栈实现（面试题7），采用的栈是可以在O(1)时间返回最大值的栈（面试题21）

剑指offer思路2：
窗口是滑动形成的，最大值可能是以前窗口中的最大值，或者是新值。因此只要保存着以前窗口的最大值。
使用双端队列容器存储最大值在数组中的索引。队列头部是以前窗口中的最大值。

当以前窗口的最大值被滑出窗口时，需要从队列头部删除。
当新值大于队列中最大的数字时，删除队列中的所有数字，存储新值到队列。（新值索引靠后，老值已经没有可能成为新窗口的最大值）
当新值不大于原有最大值时，当滑动新窗口时，仍有可能成为最大值，首先从队列尾依次删除比新值小的数字，然后存储到新值队列尾。
*/

import java.util.ArrayList;
import java.util.ArrayDeque;
import java.util.Stack;

class  MaxInWindows
{
//直接思路，O(nk)
public static  ArrayList<Integer> maxInWindows(int [] num, int size)
{
ArrayList<Integer> al=new ArrayList<Integer>();
if (num==null||num.length<=0||size<=0||size>num.length)
{
return al;
}

for (int i=0; i<=num.length-size; i++)
{
int max=num[i];
for (int j=i+1; j<i+size;  j++)
{
if (num[j]>max)
{
max=num[j];
}
}
al.add(max);
}

return al;
}

//剑指offer思路2
public static  ArrayList<Integer> maxInWindows2(int [] num, int size)
{
ArrayList<Integer> al=new ArrayList<Integer>();
if (num==null||num.length<=0||size==0)
{
return al;
}

/*
peekLast() 获取，但不移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。
pollLast() 获取并移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。
offerLast(E e) 将指定元素插入此双端队列的末尾。
peekFirst() 获取，但不移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。
pollFirst()  获取并移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。
*/
ArrayDeque<Integer> dq = new ArrayDeque<>();

//滑动窗口未满
for (int i=0; i<size; i++)
{
//当新值大于队列中最大的数字时，删除队列中的所有数字，存储新值到队列。
//当新值不大于原有最大值时，首先从队列尾依次删除比新值小的数字，然后存储到新值队列尾。
while (!dq.isEmpty()&&num[i]>=num[dq.peekLast()])
{
dq.pollLast();
}

dq.offerLast(i);//记录元素索引
}

//滑动窗口已满
for (int i=size; i<num.length; i++)
{
//第一个窗口的最大值
al.add(num[dq.peekFirst()]);

while (!dq.isEmpty()&&num[i]>=num[dq.peekLast()])
{
dq.pollLast();
}

if (!dq.isEmpty()&&i-dq.peekFirst()>=size)
{
dq.pollFirst();
}

dq.offerLast(i);
}

al.add(num[dq.peekFirst()]);

return al;
}

//剑指offer思路1：
public static  ArrayList<Integer> maxInWindows3(int [] num, int size)
{
ArrayList<Integer> al=new ArrayList<Integer>();
if (num==null||num.length<=0||size==0)
{
return al;
}

QueneWithTwoStacks quene=new QueneWithTwoStacks();
for (int i=0; i<size-1; i++)
{
quene.push(num[i]);
}

for (int i=size-1; i<num.length; i++)
{
quene.push(num[i]);
al.add(quene.max());
quene.pop();
}

return al;
}

public static void main(String[] args)
{
int[] num={2,3,4,2,6,2,5,1};
ArrayList<Integer> al=maxInWindows3(num,3);
for (int i:al )
{
System.out.println(i);
}
}
}

class QueneWithTwoStacks
{
public  StackWithMax  stack1 = new StackWithMax();
public  StackWithMax  stack2 = new StackWithMax();

public void push(int node)
{
stack1.push(node);
}

public int pop()
{
if (stack2.empty())//stack2为空时将stack1中元素移到stack2，若stack2不为空则直接弹出stack2中的栈顶
{
//将stack1中元素移到stack2，元素顺序将随之反转
while (!stack1.empty())
{
stack2.push(stack1.pop());
}
}

return stack2.pop();
}

public int max()
{
return stack2.max()>stack1.max()? stack2.max():stack1.max();
}
}

class StackWithMax
{
public  Stack<Integer> sData=new Stack<Integer>();//数据栈
public  Stack<Integer> sMax=new Stack<Integer>();//辅助栈

public void push(int node)
{
sData.push(node);

if (sMax.empty()||node>top())////压栈元素node大于最大元素时，更新最大元素，将node压入辅助栈sMax
{
sMax.push(node);
}
//压栈元素node小于最大元素时,辅助栈不进行任何操作
}

public int pop()
{
int topData=sData.pop();
if (topData==top())
{
sMax.pop();//与压栈对应，出栈元素等于最大元素时，辅助栈更新，弹出栈顶
}
//出栈元素不等于最大元素时，辅助栈不进行任何操作
return topData;
}

public int top()
{
int t=sMax.pop();
sMax.push(t);
return t;
}

public int max()
{
return top();
}

public boolean empty()
{
return sData.empty();
}

}