@TOC 和棧一樣，隊列也是表，但是使用隊列的特點是先進先出。

隊列模型

\(\color{black}{隊列的基本操作是入隊，它是在表的末端插入一個元素，和出隊，它是刪除在表開頭的一個元素}\)

隊列的循環數組實現

• 實現隊列的類

import java.util.Arrays;

/**
 * @author 李正陽
 * @param <E> 泛型存儲類型
 */
public class MyArrayQueue<E> implements queue<E> {
    /**
     * @param rear 隊尾
     * @param front 隊頭
     * @param size 數組中現在有多少個元素
     * @param MAX_CAPATIAL 數組的總大小
     * @param array 存儲元素的數組
     */
    private int rear;
    private int front;
    private int size;
    private final int MAX_CAPATIAL=10;
    private Object[] array;

    /**
     * 構造方法 初始化數組和相關的值
     */
    public MyArrayQueue(){
        array=new Object[MAX_CAPATIAL];
       rear=0;
       front=0;
       size=0;
    }

    /**
     * 入隊方法
     * 先給size遍歷加一，如果隊列滿了，就給size變量減一
     * 若隊列未滿就給隊尾加一賦值
     * @param p 需要入隊的元素
     * @return  true 成功入隊 false 入隊失敗
     */
    @Override
    public boolean push(Object p) {
        size++;
        if(isFull()){
            System.out.println("隊列滿了");
            size--;
            return false;
        }else{
            if(rear>=MAX_CAPATIAL){
                rear=0;
                array[rear++]=p;
            }else{
                array[rear++]=p;
            }
        }
        return true;
    }

    /**
     * 出隊方法
     * 先判空再出隊
     * @return 出隊的泛型類型的元素
     */
    @Override
    public E pop() {
        size--;
        E temp=(E) array[front];
        if(isEmpty()){
            System.out.println("隊列為空");
        }else{
            front++;
            if(front>MAX_CAPATIAL){
                front=0;
            }
        }
        return temp;
    }

    /**
     * 表的長度
     * @return 表中有多少哥元素
     */
    @Override
    public int size() {
        return size;
    }

    /**
     * 從表頭到表尾輸出表中的元素
     */
    @Override
    public void travel() {
        int i=front;

        while (true){
            System.out.print(array[i++]+" ");
            if(i==MAX_CAPATIAL){
                i=0;
            }
            if(i==rear){
                break;
            }
        }
        System.out.println();
    }

    /**
     * 判斷表是否為空
     * @return true 表為空 false 表不為空
     */
    @Override
    public boolean isEmpty() {
        if(size==0){

            return true;
        }else{
            return false;
        }
    }

    /**
     * @return 返回隊尾元素
     */
    @Override
    public E getRear() {
        return (E) array[rear];
    }
    /**
     * @return 返回隊頭元素
     */
    @Override
    public E getFront() {
        return (E)array[front];
    }

    /**
     * 判斷表是否滿了
     * @return true 隊列滿了 false 隊列未滿
     */
    private boolean isFull(){
        if(size>MAX_CAPATIAL){
            return true;
        }else{
            return false;
        }
    }

}


 

• 實現接口文件

/**
 * 隊列的接口
 * @param <E> 泛型類型
 */
public interface queue<E> {
     /**
      * 入隊方法
      * @param p
      * @return
      */
     boolean push(E p);

     /**
      * 出隊方法
      * @return 返回泛型類型的方法
      */
     E pop();

     /**
      * 表中元素的大小
      * @return
      */
     int size();

     /**
      * 輸出表中元素
      */
     void travel();

     /**
      * 判斷表是否為空的
      * @return true 表是空的 false 表是非空
      */
     boolean isEmpty();

     /**
      * 獲取表尾元素
      * @return 表尾的元素
      */
     E getRear();

     /**
      * 獲取表頭的元素
      * @return 表頭的元素
      */
     E getFront();
}
 

數據結構java學習（三）循環隊列