Java数据结构 - 队列与MyQueue

Java数据结构 - 队列

一、什么是队列（Queue）

队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表，队列中的元素遵循先进先出（First In First Out）原则。允许插入的一端称为队尾，允许删除的一端称为队头。

二、Java中Queue接口的结构

Java中Queue是一个接口，规范了队列数据结构应该具有的各种方法。

LinkedList类实现了Queue接口，并实现了具体方法，在实际使用队列时就需要实例化LinkedList类对象。

三、MyQueue实现类

/**
 * 模拟实现队列容器类，使用单链表存储结构
 */
public class MyQueue<E> {

    //结点内部类
    private static class Node<E>{
        E item;
        Node<E> next;

        Node(E element){
            this.item = element;
        }
    }

    /**
     * 创建一个队列对象
     */
    public MyQueue() {
    }

    private Node<E> front; //头结点指针
    private Node<E> rear; //尾结点指针
    private int size;

    /**
     * 将element入队列
     * @param element 元素对象
     * @return true
     */
    public boolean offer(E element){
        Node<E> newNode = new Node<>(element);
        if(front == null){ //若首次入队
            front = newNode;
        }else{ //从队尾入队
            rear.next = newNode;
        }
        rear = newNode;
        size++; //队列元素个数更新
        return true;
    }

    /**
     * 将队首元素出队并返回
     * @return 队首元素，如果队列为空则返回null
     */
    public E poll(){
        if(empty()){
            return null;
        }
        E polled = front.item;
        front = front.next;
        size--;
        return polled;
    }

    /**
     * 返回当前排在队首的元素
     * @return 队首元素，如果队列为空则返回null
     */
    public E peek(){
        if(empty()){
            return null;
        }
        return front.item;
    }

    /**
     * @return 返回队列是否为空
     */
    public boolean empty(){
        return size == 0;
    }

    /**
     * @return 返回队列中的元素个数
     */
    public int size(){
        return size;
    }
}

/**
 * 模拟实现队列容器类，使用循环数组存储结构
 */
public class MyQueue2<E> {

    private Object[] elementData; //存放队列元素
    private static final int DEFAULT_CAPACITY = 8; //默认初始队列长度

    private int front = 0; //队首下标
    private int rear = 0; //队尾下标

    /**
     * 创建一个默认初始长度的队列对象
     */
    public MyQueue2(){
        this.elementData = new Object[DEFAULT_CAPACITY];
    }

    /**
     * 创建一个指定初始大小的队列对象
     * @param initialCapacity 指定初始大小
     */
    public MyQueue2(int initialCapacity){
        this.elementData = new Object[initialCapacity];
    }

    /**
     * 将元素入队，如果队满则返回false
     * @param e 元素对象
     * @return 如果入队成功，返回true
     */
    public boolean offer(E e){
        if(isFull()){
            return false;
        }
        elementData[rear] = e;
        rear = (rear + 1) % elementData.length;
        return true;
    }

    //检查当前队列是否已满
    private boolean isFull(){
        return (rear + 1) % elementData.length == front;
    }

    /**
     * 将队首元素出队并返回,如果队列为空则返回null
     * @return 队首元素
     */
    @SuppressWarnings("unchecked")
    public E poll(){
        if (front == rear) {
            return null;
        }
        E polled = (E)elementData[front];
        front = (front + 1) % elementData.length;
        return polled;
    }

    /**
     * 返回队首元素，如果队列为空则返回null
     * @return 队首元素
     */
    @SuppressWarnings("unchecked")
    public E peek(){
        if (front == rear) {
            return null;
        }
        return (E)elementData[front];
    }
    
    /**
     * 计算队列实际长度
     * @return 队列实际长度
     */
    public int size(){
        return (rear - front + elementData.length) % elementData.length;
    }
}

文章为本人独立编写，难免会有错误之处。
如发现有误，恳请评论提出！