Java实现队列

抽取公共代码

public abstract class MyQueue<E> {

    int size;

    public abstract boolean enqueue(E t);

    public abstract E dequeue();

    public boolean isEmpty() {
        return size == 0;
    }
}

基于数组

public class ArrayQueue<E> extends MyQueue<E> {

    private final Object[] elements;

    private int head;
    private int tail;

    private final int capacity;
    private static final int DEFAULT_CAPACITY = 10;

    public ArrayQueue() {
        this.capacity = DEFAULT_CAPACITY;
        this.elements = new Object[capacity];
    }

    public ArrayQueue(int capacity) {
        if (capacity < 0) {
            throw new IllegalArgumentException("capacity is negative");
        }
        this.capacity = capacity;
        this.elements = new Object[capacity];
    }

    @Override
    public boolean enqueue(E e) {
        // 检查数组是否满了
        if (size == capacity) {
            return false;
        }
        elements[tail++] = e;
        // 域下面的 tail = (tail+1)%capacity 实现结果一样
        ///  if (tail == capacity) {
        //      tail = 0;
        //  }
        tail = tail % capacity;
        ++size;
        return true;
    }

    @Override
    public E dequeue() {
        // 检查数组是否为空
        if (size == 0) {
            return null;
        }
        E ele = (E) elements[head++];
        /// head = head%capacity
        if (head == capacity) {
            head = 0;
        }
        --size;
        return ele;
    }
}

基于链表

public class ListNodeQueue<E> extends MyQueue<E> {

    private ListNode<E> head;
    private ListNode<E> tail;

    /**
     * 将元素插到链表尾部
     *
     * @param ele 元素
     * @return boolean
     */
    @Override
    public boolean enqueue(E ele) {
        ListNode<E> eListNode = new ListNode<>(ele);
        if (head == null) {
            head = eListNode;
            tail = eListNode;
        } else {
            tail.next = eListNode;
            tail = eListNode;
        }
        size++;
        return true;
    }

    @Override
    public E dequeue() {
        if (head == null) {
            return null;
        }
        E ele = head.data;
        head = head.next;
        // 这里要对tail 判断
        if (head == null) {
            tail = null;
        }
        size--;
        return ele;
    }

    private static class ListNode<E> {
        private E data;
        private ListNode<E> next;

        public ListNode(E data) {
            this.data = data;
        }
    }
}

测试

public class QueueTest {

    public static void main(String[] args) {
//        MyQueue<String> queue = new ArrayQueue<>();
        MyQueue<String> queue = new ListNodeQueue<>();
        for (int i = 0; i < 5; i++) {
            queue.enqueue("data" + i);
        }
        System.out.println(queue.dequeue());
        queue.enqueue("hello");
        while (!queue.isEmpty()) {
            System.out.println(queue.dequeue());
        }
    }
}