循環隊列(貪喫蛇版)

特殊功能的循環隊列

特點:

一.入隊列不會滿的情況下,會覆蓋掉尾部的數據.

二.快速從尾部獲取指定個數個數據.

代碼:

public class LoopQueue<T> implements Serializable {

    private static final long serialVersionUID = -3670496550272478781L;

    private int DEFAULT_SIZE = 100;

    private int capacity;// 保存數組的長度

    private Object[] elementData;// 定義一個數組用於保存循環隊列的元素

    private int front = 0;// 隊頭

    private int rear = 0;// 隊尾

    // 以默認數組長度創建空循環隊列
    public LoopQueue() {
        capacity = DEFAULT_SIZE;
        elementData = new Object[capacity];
    }

    // 以一個初始化元素來創建循環隊列
    public LoopQueue(T element) {
        this();
        elementData[0] = element;
        rear++;
    }

    /**
     * 以指定長度的數組來創建循環隊列
     * 
     * @param element
     *            指定循環隊列中第一個元素
     * @param initSize
     *            指定循環隊列底層數組的長度
     */
    public LoopQueue(T element, int initSize) {
        this.capacity = initSize;
        elementData = new Object[capacity];
        elementData[0] = element;
        rear++;
    }

    /**
     * 獲取循環隊列的大小
     * 
     * @return
     */
    public int size() {
        if (isEmpty()) {
            return 0;
        }
        return rear > front ? rear - front : capacity - (front - rear);
    }

    /**
     * 入隊列
     * 
     * @param element
     */
    public void offer(T element) {
        if (size() == capacity) {
            // throw new IndexOutOfBoundsException("隊列已滿的異常");
            front = rear + 1;
            front = front == capacity ? 0 : front;
        }
        elementData[rear++] = element;
        // 如果rear已經到頭，那就轉頭
        rear = rear == capacity ? 0 : rear;
    }

    /**
     * 出隊列
     * 
     * @return
     */
    public T poll() {
        if (isEmpty()) {
            return null;
        }
        // 保留隊列的rear端的元素的值
        @SuppressWarnings("unchecked")
        T oldValue = (T) elementData[front];
        // 釋放隊列的rear端的元素
        elementData[front++] = null;
        // 如果front已經到頭，那就轉頭
        front = front == capacity ? 0 : front;
        return oldValue;
    }

    // 返回隊列頂元素，但不刪除隊列頂元素
    @SuppressWarnings("unchecked")
    public T element() {
        if (isEmpty()) {
            return null;
        }
        return (T) elementData[front];
    }

    // 判斷循環隊列是否爲空隊列
    public boolean isEmpty() {
        // rear==front且rear處的元素爲null
        return rear == front && elementData[rear] == null;
    }

    // 清空循環隊列
    public void clear() {
        // 將底層數組所有元素賦爲null
        Arrays.fill(elementData, null);
        front = 0;
        rear = 0;
    }

    /**
     * 從尾部獲取指定個數個數據
     * 
     * @param count
     * @return
     */
    public List<T> getElementsFormRear(int count) {
        List<T> result = new ArrayList<>();
        int min = size() < count ? size() : count;
        int num = 0;
        for (int i = rear - 1; num < min; i--) {
            i = i < 0 ? capacity - 1 : i;
            @SuppressWarnings("unchecked")
            T t = (T) elementData[i];
            result.add(t);
            num++;
        }
        return result;
    }

    public static void main(String[] args) {
        LoopQueue<Integer> loopQueue = new LoopQueue<>();
        for (int i = 0; i < 80; i++) {
            loopQueue.offer(i);
            System.out.println(JsonUtil.ObjectToJsonString(loopQueue.getElementsFormRear(4)));
        }
    }
}