普林斯顿公开课 算法2-9：队列

接口

队列的接口和栈的接口是类似的

• enqueue();

• dequeue();

• isEmpty();

链表方式实现

队列需要两个指针，记录头和尾。出队时与栈是一样的，入队的时候在结尾增加一个节点。

代码

public  class  LinkedQueue<T> {

     private  class  Node {

         public  T value;

         public  Node next;

     }

 

     private  Node first;

     private  Node last;

 

     public  LinkedQueue(){

     }

 

     public  void  enqueue(T value){

         Node node =  new  Node();

         node.value = value;

         node.next =  null ;

 

         if (isEmpty()){  // 处理队列为空的特殊情况

             first = node;  // 注意第一个节点

             last = node;

         }  else  {

             last.next = node;

             last = node;

         }

     }

 

     public  T dequeue(){

         T result = first.value;

         first = first.next;

 

         if (isEmpty()){  // 处理队列为空的特殊情况

             last =  null ;

         }

 

         return  result;

     }

 

     public  boolean  isEmpty(){

         return  first ==  null ;

     }

}

数组方式实现

队列也可以使用数组方式实现，当数组的使用率小于25%时，就重新调整数组的大小

代码

public  class  ArrayQueue<T> {

     private  Object[] s;

     private  int  head;

     private  int  tail;

 

     public  ArrayQueue(){

         s =  new  Object[ 2 ];

     }

 

     public  void  enqueue(T item){

         // 如果数组已满，调整数组

         if (s.length == tail){

             resize(s.length* 2 );

         }

 

         // 添加到数组的末尾

         s[tail] = item;

         tail++;

     }

 

     public  T dequeue() {

         // 返回的结果应该是队列的头部

         Object result = s[head];

         head++;

 

         // 如果队列使用率不到1/4，则调整数组大小

         int  size =  this .size();

         if (size >=  2  && size < s.length/ 4 ){

             resize(s.length/ 2 );

         }

 

         // 返回结果

         return  (T)result;

     }

 

     private  void  resize( int  size){

         //复制一份新的数组

         Object[] copy =  new  Object[size];

         int  queueSize =  this .size();

         for ( int  i= 0 ;i<queueSize;i++){

             copy[i] = s[i+head];

         }

         s = copy;

 

         // 重置指针

         head= 0 ;

         tail=queueSize;

     }

 

     // 队列长度

     private  int  size() {

         return  tail-head;

     }

}