java实现队列
Ⅰ 用java编一个队列
自己写了个简单的实现
class Queue<E>{
private Object[] integerQueue;//用来当队列
public int tail;//队尾
public int size;//队的长度，也可以设置一个默认值，溢出时从新申请
public Queue(int size){
integerQueue=new Object[size];
this.size=size;
tail=-1;
}
/**
* 将元素插入队列
* @return 如果该元素已添加到此队列，则返回 true；否则返回 false
*/
public boolean offer(E e){
if(tail <size-1){
tail++;
this.integerQueue[tail]=e;
return true;
}else{
return false;
}
}
/**
* 获取并移除此队列的头，如果此队列为空，则返回 null。
*/
public E poll(){
Object tmp;
if(tail>=0){
tmp=this.integerQueue[tail];
tail--;
return (E)tmp;
}else{
return null;
}
}
}
Ⅱ java中的队列用什么实现
队列的实现单纯的是数据结构的问题，既可以用链表结构实现队列，也可以用数组实现。这和语言不是紧密关系，java可以这样实现，C、C++ 也可以。
Ⅲ 到底什么是消息队列Java中如何实现消息队列
“消息队列”是在消息的传输过程中保存消息的容器。和我们学过的LinkedHashMap，TreeSet等一样，都是容器。既然是容器，就有有自己的特性，就像LinkedHashMap是以键值对存储。存取顺序不变。而消息队列，看到队列就可以知道。这个容器里面的消息是站好队的，一般遵从先进先出原则。
java中已经为我们封装好了很多的消息队列。在java 1.5版本时推出的java.util.concurrent中有很多现成的队列供我们使用。特性繁多，种类齐全。是你居家旅游开发必备QAQ。
下面简单列举这个包中的消息队列
:阻塞队列 BlockingQueue
数组阻塞队列 ArrayBlockingQueue
延迟队列 DelayQueue
链阻塞队列 LinkedBlockingQueue
具有优先级的阻塞队列 PriorityBlockingQueue
同步队列 SynchronousQueue
阻塞双端队列 BlockingDeque
链阻塞双端队列 LinkedBlockingDeque
不同的队列不同的特性决定了队列使用的时机，感兴趣的话你可以详细了解。具体的使用方式我就不赘述了
Ⅳ 在JAVA中怎么实现消息队列
java中的消息队列
消息队列是线程间通讯的手段：
import java.util.*
public class MsgQueue{
private Vector queue = null;
public MsgQueue(){
queue = new Vector();
}
public synchronized void send(Object o)
{
queue.addElement(o);
}
public synchronized Object recv()
{
if(queue.size()==0)
return null;
Object o = queue.firstElement();
queue.removeElementAt(0);//or queue[0] = null can also work
return o;
}
}
因为java中是locked by object的所以添加synchronized 就可以用于线程同步锁定对象
可以作为多线程处理多任务的存放task的队列。他的client包括封装好的task类以及thread类
Java的多线程-线程间的通信2009-08-25 21:58
1. 线程的几种状态
线程有四种状态，任何一个线程肯定处于这四种状态中的一种：
1) 产生（New）：线程对象已经产生，但尚未被启动，所以无法执行。如通过new产生了一个线程对象后没对它调用start()函数之前。
2) 可执行（Runnable）：每个支持多线程的系统都有一个排程器，排程器会从线程池中选择一个线程并启动它。当一个线程处于可执行状态时，表示它可能正处于线程池中等待排排程器启动它；也可能它已正在执行。如执行了一个线程对象的start()方法后，线程就处于可执行状态，但显而易见的是此时线程不一定正在执行中。
3) 死亡（Dead）：当一个线程正常结束，它便处于死亡状态。如一个线程的run()函数执行完毕后线程就进入死亡状态。
4) 停滞（Blocked）：当一个线程处于停滞状态时，系统排程器就会忽略它，不对它进行排程。当处于停滞状态的线程重新回到可执行状态时，它有可能重新执行。如通过对一个线程调用wait()函数后，线程就进入停滞状态，只有当两次对该线程调用notify或notifyAll后它才能两次回到可执行状态。
2. classThread下的常用函数函数
2.1 suspend()、resume()
1) 通过suspend()函数，可使线程进入停滞状态。通过suspend()使线程进入停滞状态后，除非收到resume()消息，否则该线程不会变回可执行状态。
2) 当调用suspend()函数后，线程不会释放它的“锁标志”。
例11：
class TestThreadMethod extends Thread{
public static int shareVar = 0;
public TestThreadMethod(String name){
super(name);
}
public synchronized void run(){
if(shareVar==0){
for(int i=0; i<5; i++){
shareVar++;
if(shareVar==5){
this.suspend();//（1）
}}}
else{
System.out.print(Thread.currentThread().getName());
System.out.println(" shareVar = " + shareVar);
this.resume();//（2）
}}
}
public class TestThread{
public static void main(String[] args){
TestThreadMethod t1 = new TestThreadMethod("t1");
TestThreadMethod t2 = new TestThreadMethod("t2");
t1.start();//（5）
//t1.start();//（3）
t2.start();//（4）
}}
运行结果为：
t2 shareVar = 5
i. 当代码（5）的t1所产生的线程运行到代码（1）处时，该线程进入停滞状态。然后排程器从线程池中唤起代码（4）的t2所产生的线程，此时shareVar值不为0，所以执行else中的语句。
ii. 也许你会问，那执行代码（2）后为什么不会使t1进入可执行状态呢？正如前面所说，t1和t2是两个不同对象的线程，而代码（1）和（2）都只对当前对象进行操作，所以t1所产生的线程执行代码（1）的结果是对象t1的当前线程进入停滞状态；而t2所产生的线程执行代码（2）的结果是把对象t2中的所有处于停滞状态的线程调回到可执行状态。
iii. 那现在把代码（4）注释掉，并去掉代码（3）的注释，是不是就能使t1重新回到可执行状态呢？运行结果是什么也不输出。为什么会这样呢？也许你会认为，当代码（5）所产生的线程执行到代码（1）时，它进入停滞状态；而代码（3）所产生的线程和代码（5）所产生的线程是属于同一个对象的，那么就当代码（3）所产生的线程执行到代码（2）时，就可使代码（5）所产生的线程执行回到可执行状态。但是要清楚，suspend()函数只是让当前线程进入停滞状态，但并不释放当前线程所获得的“锁标志”。所以当代码（5）所产生的线程进入停滞状态时，代码（3）所产生的线程仍不能启动，因为当前对象的“锁标志”仍被代码（5）所产生的线程占有。
#p#2.2 sleep()
1) sleep ()函数有一个参数，通过参数可使线程在指定的时间内进入停滞状态，当指定的时间过后，线程则自动进入可执行状态。
2) 当调用sleep ()函数后，线程不会释放它的“锁标志”。
例12：
class TestThreadMethod extends Thread{
class TestThreadMethod extends Thread{
public static int shareVar = 0;
public TestThreadMethod(String name){
super(name);
}
public synchronized void run(){
for(int i=0; i<3; i++){
System.out.print(Thread.currentThread().getName());
System.out.println(" : " + i);
try{
Thread.sleep(100);//（4）
}
catch(InterruptedException e){
System.out.println("Interrupted");
}}}
}
public class TestThread{public static void main(String[] args){
TestThreadMethod t1 = new TestThreadMethod("t1");
TestThreadMethod t2 = new TestThreadMethod("t2");
t1.start();（1）
t1.start();（2）
//t2.start();（3）
}}
运行结果为：
t1 : 0
t1 : 1
t1 : 2
t1 : 0
t1 : 1
t1 : 2
由结果可证明，虽然在run()中执行了sleep()，但是它不会释放对象的“锁标志”，所以除非代码(1)的线程执行完run()函数并释放对象的“锁标志”，否则代码（2）的线程永远不会执行。
如果把代码（2）注释掉，并去掉代码（3）的注释，结果将变为：
t1 : 0
t2 : 0
t1 : 1
t2 : 1
t1 : 2
t2 : 2
由于t1和t2是两个对象的线程，所以当线程t1通过sleep()进入停滞时，排程器会从线程池中调用其它的可执行线程，从而t2线程被启动。
例13：
class TestThreadMethod extends Thread{
public static int shareVar = 0;
public TestThreadMethod(String name){
super(name);
}
public synchronized void run(){
for(int i=0; i<5; i++){
System.out.print(Thread.currentThread().getName());
System.out.println(" : " + i);
try{
if(Thread.currentThread().getName().equals("t1"))
Thread.sleep(200);
else
Thread.sleep(100);
}
catch(InterruptedException e){
System.out.println("Interrupted");
}}
}}
public class TestThread{public static void main(String[] args){
TestThreadMethod t1 = new TestThreadMethod("t1");
TestThreadMethod t2 = new TestThreadMethod("t2");
t1.start();
//t1.start();
t2.start();
}}
运行结果为：
t1 : 0
t2 : 0
t2 : 1
t1 : 1
t2 : 2
t2 : 3
t1 : 2
t2 : 4
t1 : 3
t1 : 4
由于线程t1调用了sleep(200)，而线程t2调用了sleep(100)，所以线程t2处于停滞状态的时间是线程t1的一半，从从结果反映出来的就是线程t2打印两倍次线程t1才打印一次。
#p#2.3 yield()
1) 通过yield ()函数，可使线程进入可执行状态，排程器从可执行状态的线程中重新进行排程。所以调用了yield()的函数也有可能马上被执行。
2) 当调用yield ()函数后，线程不会释放它的“锁标志”。
例14：
class TestThreadMethod extends Thread{
public static int shareVar = 0;
public TestThreadMethod(String name){super(name);
}
public synchronized void run(){for(int i=0; i<4; i++){
System.out.print(Thread.currentThread().getName());
System.out.println(" : " + i);
Thread.yield();
}}
}
public class TestThread{public static void main(String[] args){
TestThreadMethod t1 = new TestThreadMethod("t1");
TestThreadMethod t2 = new TestThreadMethod("t2");
t1.start();
t1.start();//（1）
//t2.start();（2）
}
}
运行结果为：
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t1 : 0
t1 : 1
t1 : 2
t1 : 3
从结果可知调用yield()时并不会释放对象的“锁标志”。
如果把代码（1）注释掉，并去掉代码（2）的注释，结果为：
t1 : 0
t1 : 1
t2 : 0
t1 : 2
t2 : 1
t1 : 3
t2 : 2
t2 : 3
从结果可知，虽然t1线程调用了yield()，但它马上又被执行了。
2.4 sleep()和yield()的区别
1) sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
2) sleep()可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会；yield()只能使同优先级的线程有执行的机会。
例15：
class TestThreadMethod extends Thread{
public static int shareVar = 0;
public TestThreadMethod(String name){
super(name);
}
public void run(){
for(int i=0; i<4; i++){
System.out.print(Thread.currentThread().getName());
System.out.println(" : " + i);
//Thread.yield();（1）
/* （2） */
try{
Thread.sleep(3000);
}
catch(InterruptedException e){
System.out.println("Interrupted");
}}}
}
public class TestThread{
public static void main(String[] args){
TestThreadMethod t1 = new TestThreadMethod("t1");
TestThreadMethod t2 = new TestThreadMethod("t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
}
运行结果为：
t1 : 0
t1 : 1
t2 : 0
t1 : 2
t2 : 1
t1 : 3
t2 : 2
t2 : 3
由结果可见，通过sleep()可使优先级较低的线程有执行的机会。注释掉代码（2），并去掉代码（1）的注释，结果为：
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t2 : 0
t2 : 1
t2 : 2
t2 : 3
可见，调用yield()，不同优先级的线程永远不会得到执行机会。
2.5 join()
使调用join()的线程执行完毕后才能执行其它线程，在一定意义上，它可以实现同步的功能。
例16：
class TestThreadMethod extends Thread{
public static int shareVar = 0;
public TestThreadMethod(String name){
super(name);
}
public void run(){
for(int i=0; i<4; i++){
System.out.println(" " + i);
try{
Thread.sleep(3000);
}
catch(InterruptedException e){
System.out.println("Interrupted");
}
}
}
}
public class TestThread{
public static void main(String[] args){
TestThreadMethod t1 = new TestThreadMethod("t1");
t1.start();
try{
t1.join();
}
catch(InterruptedException e){}
t1.start();
}
}
运行结果为：
0
1
2
3
0
1
2
3
#p#3. classObject下常用的线程函数
wait()、notify()和notifyAll()这三个函数由java.lang.Object类提供，用于协调多个线程对共享数据的存取。
3.1 wait()、notify()和notifyAll()
1) wait()函数有两种形式：第一种形式接受一个毫秒值，用于在指定时间长度内暂停线程，使线程进入停滞状态。第二种形式为不带参数，代表waite()在notify()或notifyAll()之前会持续停滞。
2) 当对一个对象执行notify()时，会从线程等待池中移走该任意一个线程，并把它放到锁标志等待池中；当对一个对象执行notifyAll()时，会从线程等待池中移走所有该对象的所有线程，并把它们放到锁标志等待池中。
3) 当调用wait()后，线程会释放掉它所占有的“锁标志”，从而使线程所在对象中的其它synchronized数据可被别的线程使用。
例17：
下面，我们将对例11中的例子进行修改
class TestThreadMethod extends Thread{
public static int shareVar = 0;
public TestThreadMethod(String name){
super(name);
}
public synchronized void run(){
if(shareVar==0){
for(int i=0; i<10; i++){
shareVar++;
if(shareVar==5){
try{
this.wait();//（4）
}
catch(InterruptedException e){}
}
}
}
if(shareVar!=0){
System.out.print(Thread.currentThread().getName());
System.out.println(" shareVar = " + shareVar);
this.notify();//（5）
}
}
}
public class TestThread{
public static void main(String[] args){
TestThreadMethod t1 = new TestThreadMethod("t1");
TestThreadMethod t2 = new TestThreadMethod("t2");
t1.start();//（1）
//t1.start();（2）
t2.start();//（3）
}}
运行结果为：
t2 shareVar = 5
因为t1和t2是两个不同对象，所以线程t2调用代码（5）不能唤起线程t1。如果去掉代码（2）的注释，并注释掉代码（3），结果为：
t1 shareVar = 5
t1 shareVar = 10
这是因为，当代码（1）的线程执行到代码（4）时，它进入停滞状态，并释放对象的锁状态。接着，代码（2）的线程执行run()，由于此时shareVar值为5，所以执行打印语句并调用代码（5）使代码（1）的线程进入可执行状态，然后代码（2）的线程结束。当代码（1）的线程重新执行后，它接着执行for()循环一直到shareVar=10，然后打印shareVar。
#p#3.2 wait()、notify()和synchronized
waite()和notify()因为会对对象的“锁标志”进行操作，所以它们必须在synchronized函数或synchronizedblock中进行调用。如果在non-synchronized函数或non-synchronizedblock中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。
例18：
class TestThreadMethod extends Thread{
public int shareVar = 0;
public TestThreadMethod(String name){
super(name);
new Notifier(this);
}
public synchronized void run(){
if(shareVar==0){
for(int i=0; i<5; i++){
shareVar++;
System.out.println("i = " + shareVar);
try{
System.out.println("wait......");
this.wait();
}
catch(InterruptedException e){}
}}
}
}
class Notifier extends Thread{
private TestThreadMethod ttm;
Notifier(TestThreadMethod t){
ttm = t;
start();
}
public void run(){
while(true){
try{
sleep(2000);
}
catch(InterruptedException e){}
/*1 要同步的不是当前对象的做法 */
synchronized(ttm){
System.out.println("notify......");
ttm.notify();
}}
}
}
public class TestThread{
public static void main(String[] args){
TestThreadMethod t1 = new TestThreadMethod("t1");
t1.start();
}
}
运行结果为：
i = 1
wait......
notify......
i = 2
wait......
notify......
i = 3
wait......
notify......
i = 4
wait......
notify......
i = 5
wait......
notify......
4. wait()、notify()、notifyAll()和suspend()、resume()、sleep()的讨论
4.1 这两组函数的区别
1) wait()使当前线程进入停滞状态时，还会释放当前线程所占有的“锁标志”，从而使线程对象中的synchronized资源可被对象中别的线程使用；而suspend()和sleep()使当前线程进入停滞状态时不会释放当前线程所占有的“锁标志”。
2) 前一组函数必须在synchronized函数或synchronizedblock中调用，否则在运行时会产生错误；而后一组函数可以non-synchronized函数和synchronizedblock中调用。
4.2 这两组函数的取舍
Java2已不建议使用后一组函数。因为在调用suspend()时不会释放当前线程所取得的“锁标志”，这样很容易造成“死锁”。
Ⅳ java中如何实现按队列执行任务
package com.tone.example;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.tone.task.TaskProperty;
import com.tone.task.TaskSignature;
import com.tone.task.impl.BasicTask;
import com.tone.task.runner.TaskRunner;
/**
* 任务队列示例程序
* @author zlf
*/
public class TaskExample {
private TaskRunner taskRunner;
/**
* 做任务队列的初始化工作
*/
@Before
public void init() {
// 获取任务运行器
taskRunner = TaskRunner.getInstance();
// 将任务运行器放入线程进行调度
Thread thread = new Thread(taskRunner);
thread.start();
}
/**
* 等待任务执行完成，并做最后的退出工作
*/
@After
public void exit() throws InterruptedException {
Thread.sleep(600);
System.exit(0);
}
/**
* 最简单的任务运行示例
*/
@Test
public void example1() {
// 添加任务到任务运行器
taskRunner.addTask(new BasicTask() {
@Override
public void run() {
System.out.println("This is running in task runner thread, and thread is " + Thread.currentThread());
}
});
}
/**
* 加入优先执行顺序的任务运行器
*/
@Test
public void example2() {
// 添加任务到任务运行器
taskRunner.addTask(new BasicTask(0) {
@Override
public void run() {
System.out.println("This is a normal task");
}
});
taskRunner.addTask(new BasicTask(-1) {
@Override
public void run() {
System.out.println("This is a task a bit high than normal");
}
});
}
/**
* 重复添加的任务只会运行第一个
*/
@Test
public void example3() {
// 添加任务到任务运行器
taskRunner.addTask(new BasicTask(TaskSignature.ONE) {
@Override
public void run() {
System.out.println("This is task one");
}
}, TaskProperty.NOT_REPEAT);
taskRunner.addTask(new BasicTask(TaskSignature.ONE) {
@Override
public void run() {
System.out.println("This is also task one");
}
}, TaskProperty.NOT_REPEAT);
}
/**
* 重复添加的任务只会运行最后一个
*/
@Test
public void example4() {
// 添加任务到任务运行器
taskRunner.addTask(new BasicTask(TaskSignature.ONE) {
@Override
public void run() {
System.out.println("This is task one");
}
}, TaskProperty.NOT_REPEAT_OVERRIDE);
taskRunner.addTask(new BasicTask(TaskSignature.ONE) {
@Override
public void run() {
System.out.println("This is also task one");
}
}, TaskProperty.NOT_REPEAT_OVERRIDE);
}
}
Ⅵ JAVA中，常用的队列实现是哪个
队列的实现单纯的是数据结构的问题，既可以用链表结构实现队列，也可以用数组实现。这和语言不是紧密关系，java可以这样实现，c、c++
也可以。
Ⅶ java 用什么实现 FIFO队列
java使用数据结构来实现FIFO先进先出的队列，实例如下：
/*
*Tochangethistemplate,chooseTools|Templates
*andopenthetemplateintheeditor.
*/
packagelinkedlisttest;
importjava.util.ArrayList;
importjava.util.Deque;
importjava.util.LinkedList;
importjava.util.List;
/**
*
*@authorVicky.H
*@[email protected]
*/
publicclassFIFOTest{
/**
*@
*/
publicstaticvoidmain(String[]args){
FIFO<A>fifo=newFIFOImpl<A>(5);
for(inti=0;i<20;i++){
Aa=newA("A:"+i);
Ahead=fifo.addLastSafe(a);
System.out.println(i+" head:"+head+" size:"+fifo.size());
}
System.out.println("---------------");
System.out.println("弹出数据");
List<A>polls=fifo.setMaxSize(3);
for(Aa:polls){
System.out.println(" head:"+a);
}
System.out.println("剩余数据");
for(Aa:fifo){
System.out.println(" head:"+a);
}
System.out.println(fifo.size());
}
}
interfaceFIFO<T>extendsList<T>,Deque<T>,Cloneable,java.io.Serializable{
/**
*向最后添加一个新的，如果长度超过允许的最大值，则弹出一个*
*/
TaddLastSafe(TaddLast);
/**
*弹出head，如果Size=0返回null。而不同于pop抛出异常
*@return
*/
TpollSafe();
/**
*获得最大保存
*
*@return
*/
intgetMaxSize();
/**
*设置最大存储范围
*
*@return返回的是，因为改变了队列大小，导致弹出的head
*/
List<T>setMaxSize(intmaxSize);
}
classFIFOImpl<T>extendsLinkedList<T>implementsFIFO<T>{
privateintmaxSize=Integer.MAX_VALUE;
privatefinalObjectsynObj=newObject();
publicFIFOImpl(){
super();
}
publicFIFOImpl(intmaxSize){
super();
this.maxSize=maxSize;
}
@Override
publicTaddLastSafe(TaddLast){
synchronized(synObj){
Thead=null;
while(size()>=maxSize){
head=poll();
}
addLast(addLast);
returnhead;
}
}
@Override
publicTpollSafe(){
synchronized(synObj){
returnpoll();
}
}
@Override
publicList<T>setMaxSize(intmaxSize){
List<T>list=null;
if(maxSize<this.maxSize){
list=newArrayList<T>();
synchronized(synObj){
while(size()>maxSize){
list.add(poll());
}
}
}
this.maxSize=maxSize;
returnlist;
}
@Override
publicintgetMaxSize(){
returnthis.maxSize;
}
}
classA{
privateStringname;
publicA(){
}
publicA(Stringname){
this.name=name;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
@Override
publicStringtoString(){
return"A{"+"name="+name+'}';
}
}
Ⅷ java中怎么实现队列
public class Queue<E> {
private Object[] data=null;
private int maxSize; //队列容量
private int front; //队列头，允许删除
private int rear; //队列尾，允许插入
//构造函数
public Queue(){
this(10);
}
public Queue(int initialSize){
if(initialSize >=0){
this.maxSize = initialSize;
data = new Object[initialSize];
front = rear =0;
}else{
throw new RuntimeException("初始化大小不能小于0：" + initialSize);
}
}
//判空
public boolean empty(){
return rear==front?true:false;
}
//插入
public boolean add(E e){
if(rear== maxSize){
throw new RuntimeException("队列已满，无法插入新的元素！");
}else{
data[rear++]=e;
return true;
}
}
//返回队首元素，但不删除
public E peek(){
if(empty()){
throw new RuntimeException("空队列异常！");
}else{
return (E) data[front];
}
}
//出队
public E poll(){
if(empty()){
throw new RuntimeException("空队列异常！");
}else{
E value = (E) data[front]; //保留队列的front端的元素的值
data[front++] = null; //释放队列的front端的元素
return value;
}
}
//队列长度
public int length(){
return rear-front;
}
}
Ⅸ java动态增长队列的实现
java里面支持队列这种数据结构，只要实现Queue<E>接口即可，比如下面实现了一个能容纳String的队列：
import java.util.*;
public class DynamicQueue{
private Queue<String> queue = new LinkedList<String>();
public void enque(String s) {
queue.offer(s);
}
public String deque() {
return queue.poll();
}
public static void main(String[] args){
DynamicQueue d_queue = new DynamicQueue();
d_queue.enque("123");
d_queue.enque("234");
d_queue.enque("345");
System.out.println(d_queue.deque());
System.out.println(d_queue.deque());
System.out.println(d_queue.deque());
}
}
Ⅹ 单调队列怎么用java实现
单调队列是一种严格单调的队列，可以单调递增，也可以单调递减。队首位置保存的是最优解，第二个位置保存的是次优解，ect。。。
单调队列可以有两个操作：
1、插入一个新的元素，该元素从队尾开始向队首进行搜索，找到合适的位置插入之，如果该位置原本有元素，则替换它。
2、在过程中从队首删除不符合当前要求的元素。
单调队列实现起来可简单，可复杂。简单的一个数组，一个head，一个tail指针就搞定。复杂的用双向链表实现。
用处：
1、保存最优解，次优解，ect。
2、利用单调队列对dp方程进行优化，可将O(n)复杂度降至O(1)。也就是说，将原本会超时的N维dp降优化至N-1维，以求通过。这也是我想记录的重点
是不是任何DP都可以利用单调队列进行优化呢？答案是否定的。
记住！只有形如 dp[i]=max/min (f[k]) + g[i] （k<i && g[i]是与k无关的变量）才能用到单调队列进行优化。
优化的对象就是f[k]。
通过例题来加深感受
http://www.acm.uestc.e.cn/problem.php?pid=1685
我要长高
Description
韩父有N个儿子，分别是韩一，韩二…韩N。由于韩家演技功底深厚，加上他们间的密切配合，演出获得了巨大成功，票房甚至高达2000万。舟子是名很有威望的公知，可是他表面上两袖清风实则内心阴暗，看到韩家红红火火，嫉妒心遂起，便发微薄调侃韩二们站成一列时身高参差不齐。由于舟子的影响力，随口一句便会造成韩家的巨大损失，具体亏损是这样计算的，韩一，韩二…韩N站成一排，损失即为C*（韩i与韩i+1的高度差（1<=i<N））之和，搞不好连女儿都赔了.韩父苦苦思索，决定给韩子们内增高（注意韩子们变矮是不科学的只能增高或什么也不做），增高1cm是很容易的，可是增高10cm花费就很大了，对任意韩i，增高Hcm的花费是H^2.请你帮助韩父让韩家损失最小。
Input
有若干组数据，一直处理到文件结束。 每组数据第一行为两个整数：韩子数量N(1<=N<=50000)和舟子系数C(1<=C<=100) 接下来N行分别是韩i的高度(1<=hi<=100)。
首先建立方程，很容易想到的是，dp[i][j]表示第 i 个儿子身高为 j 的最低花费。分析题目很容易知道，当前儿子的身高花费只由前一个儿子影响。因此，
dp[i][j]=min(dp[i-1][k] + abs(j-k)*C + (x[i]-j)*(x[i]-j))；其中x[i]是第i个儿子原本的身高
我们分析一下复杂度。
首先有N个儿子，这需要一个循环。再者，每个儿子有0到100的身高，这也需要一维。再再者，0到100的每一个身高都可以有前一位儿子的身高0到100递推而来。
所以朴素算法的时间复杂度是O(n^3)。题目只给两秒，难以接受！
分析方程：
当第 i 个儿子的身高比第 i-1 个儿子的身高要高时，
dp[i][j]=min(dp[i-1][k] + j*C-k*C + X); ( k<=j ) 其中 X=(x[i]-j)*(x[i]-j)。
当第 i 个儿子的身高比第 i-1 个儿子的身高要矮时，
dp[i][j]=min(dp[i-1][k] - j*C+k*C + X); ( k>=j )
对第一个个方程，我们令 f[i-1][k]=dp[i-1][k]-k*C, g[i][j]=j*C+X; 于是 dp[i][j] = min (f[i-1][k])+ g[i][j]。转化成这样的形式，我们就可以用单调队列进行优化了。
第二个方程同理。
接下来便是如何实现，实现起来有点技巧。具体见下
View Code
还有一个比较适合理解该优化方法的题目是HDU 3401http://acm.h.e.cn/showproblem.php?pid=3401
大概题目便是：一个人知道接下来T天的股市行情，想知道最终他能赚到多少钱。
构造状态dp[i][j]表示第i 天拥有 j只股票的时候，赚了多少钱
状态转移有：
1、从前一天不买不卖:
dp[i][j]=max(dp[i-1][j],dp[i][j])
2、从前i-W-1天买进一些股:
dp[i][j]=max(dp[i-W-1][k]-(j-k)*AP[i],dp[i][j])
3、从i-W-1天卖掉一些股:
dp[i][j]=max(dp[i-W-1][k]+(k-j)*BP[i],dp[i][j])
这里需要解释一下为什么只考虑第i-W-1天的买入卖出情况即可。想想看，i-W-2天是不是可以通过不买不卖将自己的最优状态转移到第i-W-1天？以此类推，之前的都不需要考虑了，只考虑都i-W-1天的情况即可。
对买入股票的情况进行分析，转化成适合单调队列优化的方程形式
dp[i][j]=max(dp[i-W-1][k]+k*AP[i])-j*AP[i]。令f[i-W-1][k]=dp[i-W-1][k]+k*AP[i]，则dp[i][j]=max(f[i-W-1][k]) - j*AP[i]。
这便可以用单调队列进行优化了。卖股的情况类似分析。
View Code
最后再说一个应用，用单调队列来优化多重背包问题 h 2191
如果有n个物品，每个物品的价格是w，重量是c，且每个物品的数量是k，那么用这样的一些物品去填满一个容量为m的背包，使得得到的背包价值最大化，这样的问题就是多重背包问题。
对于多重背包的问题，有一种优化的方法是使用二进制优化，这种优化的方法时间复杂度是O(m*∑log k[i])，具体可以见
http://www.cnblogs.com/ka200812/archive/2011/08/06/2129505.html
而利用单调队列的优化，复杂度是O(mn)
首先，对于第i件物品，如果已知体积为V，价值为W，数量为K，那么可以按照V的余数，将当前的体积J分成V组(0,1,....V-1)。
对于任意一组，可以得到转移方程：f[i*V+c]=f[k*V+c]+(i-k)*W，其中c是V组分组中的任意一个
令f[i*V+c]=dp[i]，那么就得到dp[i]=dp[k]+(i-k)*W (k>=i-K)
将dp[k]-k*W看做是优化函数，那么就可以运用单调队列来优化了