java实现队列

顺序队列参考：http://www.cnblogs.com/CherishFX/p/4608880.html

实现：

package 队列;

import javax.management.RuntimeErrorException;

public class MyQueue<E> {
    private Object[] data = null;
    private int maxSize;//队列容量
    private int front;//对列头
    private int rear;//队列尾
    
    public MyQueue() {
        this(10);
    }

    public MyQueue(int init) {
        if(init<0) {
            throw new RuntimeException("初始化大小不能小于0："+init);
        }else {
            maxSize = init;
            data = new Object[maxSize];
            front = rear = 0;
        }
    }
    
    /**
     * 判断是否队列为空
     * @return
     */
    public boolean empty(){
        return rear==front;
    }
    
    /**
     * 入队
     * @param e
     * @return
     */
    public boolean add(E e){
        if(rear== maxSize-1){
            throw new RuntimeException("队列已满，无法插入新的元素！");
        }else{
            data[rear++]=e;
            return true;
        }
    }
    
    /**
     * 查看队列首位
     * @return
     */
    public E peek(){
        if(empty()){
            throw new RuntimeException("空队列异常！");
        }else{
            return (E) data[front];
        }    
    }
    
   /**
    * 出队
    * @return
    */
    public E poll(){
        if(empty()){
            throw new RuntimeException("空队列异常！");
        }else{
            E temp = (E) data[front];  //保留队列的front端的元素的值
            data[front++] = null;     //释放队列的front端的元素                
            return temp;
        }            
    }
    
    /**
     * 队列长度
     * @return
     */
    public int length(){
        return rear-front;
    }
    
    public static void main(String[] args) {
        MyQueue<Integer> q = new MyQueue<>();
        q.add(5);q.add(6);q.add(7);
        System.out.println(q.length());
        q.poll();
    }

}

顺序表实现循环队列:

package 队列;

import java.util.Arrays;

public class MyLoopQueue<E> {
    public Object[] data = null;
    private int maxSize; // 队列容量
    private int rear;// 队列尾，允许插入
    private int front;// 队列头，允许删除
    private int size=0; //队列当前长度
    
    public MyLoopQueue() {
        this(10);
    }

    public MyLoopQueue(int init) {
        if (init >= 0) {
            this.maxSize = init;
            data = new Object[init];
            front = rear = 0;
        } else {
            throw new RuntimeException("初始化大小不能小于0：" + init);
        }
    }
    
    /**
     * 判断是否队列为空
     * @return
     */
    public boolean empty(){
        return size==0;
    }
    
    /**
     * 入队
     * @param e
     * @return
     */
    public boolean add(E e){
        if(size== maxSize){
            throw new RuntimeException("队列已满，无法插入新的元素！");
        }else{
            data[rear]=e;
            rear = (rear + 1) % maxSize;
            size++;
            return true;
        }
    }
    
    /**
     * 查看队列首位
     * @return
     */
    public E peek(){
        if(empty()){
            throw new RuntimeException("空队列异常！");
        }else{
            return (E) data[front];
        }    
    }
    
   /**
    * 出队
    * @return
    */
    public E poll(){
        if(empty()){
            throw new RuntimeException("空队列异常！");
        }else{
            E temp = (E) data[front];  //保留队列的front端的元素的值
            data[front] = null;     //释放队列的front端的元素      
            front = (front+1)%maxSize;
            size--;
            return temp;
        }            
    }
    
    /**
     * 队列长度
     * @return
     */
    public int length(){
        return size;
    }
    
    /**
     *  清空循环队列
     */
    public void clear(){
        Arrays.fill(data, null);
        size = 0;
        front = 0;
        rear = 0;
    }
    
    public static void main(String[] args) {
        MyLoopQueue<Integer> q = new MyLoopQueue<>();
        q.add(5);q.add(6);q.add(7);
        System.out.println(q.length());
        q.poll();
        System.out.println(q.length());
        q.clear();
        System.out.println(q.length());
    }
    
}

链式队列实现

package 队列;

public class LinkQueue<E> {
    // 链栈的节点
    private class Node<E> {
        E e;
        Node<E> next;

        public Node() {
        }

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }
    }
    
    private Node front;// 队列头，允许删除  
    private Node rear;// 队列尾，允许插入  
    private int size; //队列当前长度 
    
    public LinkQueue() {
        front = null;
        rear = null;
    }
    
    //判空
      public boolean empty(){
          return size==0;
      }
      
      //插入
      public boolean add(E e){
          if(empty()){    //如果队列为空
              front = new Node(e,null);//只有一个节点，front、rear都指向该节点
              rear = front;
          }else{
              Node<E> newNode = new Node<E>(e, null);
              rear.next = newNode; //让尾节点的next指向新增的节点
              rear = newNode; //以新节点作为新的尾节点
          }
          size ++;
          return true;
      }
      
      //返回队首元素，但不删除
      public Node<E> peek(){
          if(empty()){
              throw new RuntimeException("空队列异常！");
          }else{
              return front;
          }
      }
      
      //出队
      public Node<E> poll(){
          if(empty()){
              throw new RuntimeException("空队列异常！");
          }else{
              Node<E> value = front; //得到队列头元素
              front = front.next;//让front引用指向原队列头元素的下一个元素
              value.next = null; //释放原队列头元素的next引用
              size --;
              return value;
          }        
      }
      
      //队列长度
      public int length(){
          return size;
      }
      
      public static void main(String[] args) {
        LinkQueue<Integer> q = new LinkQueue<>();
        q.add(5);q.add(6);q.add(7);
        System.out.println(q.length());
        q.poll();
        System.out.println(q.length());
    }
}

所有内容均个人编辑（除特别标注外），如有错误，欢迎指正！
.