队列的链式实现和循环数组实现-----------------------------java语言描述

Java有经典的链式队列，循环队列，也有高级应用常使用的双向队列，优先队列。本文从低级实现介绍到java类库中的相关队列。

队列的接口

如下所示：

public interface QueueInterface <T>{ //所有队列的实现必须实现这个接口
    public void enqueue(T newEntry);
    
    public T dequeue();
    
    public T getFront();
    
    public boolean isEmpty();
    
    public void clear();
}

链式队列

首先，写一个LinkedQueue，实现QueueInterface接口.

/** 
 * Description: 链式结构实现队列
 *
 * @ClassName: LinkedQueue
 * @author 过道
 * @date 2018年8月13日 下午3:18:18 
 */
public class LinkedQueue<T> implements QueueInterface<T>{

    /**
     * Title: enqueue 
     *
     * Description: 队列尾部新增元素 newEntry
     */
    @Override
    public void enqueue(T newEntry) {
        // TODO Auto-generated method stub
        
    }

    /**
     * Title: dequeue 
     *
     * Description: 队列头部删除元素
     */
    @Override
    public T dequeue() {
        // TODO Auto-generated method stub
        return null;
    }

    /**
     * Title: getFront 
     *
     * Description: 得到头部元素，同peek()
     */
    @Override
    public T getFront() {
        // TODO Auto-generated method stub
        return null;
    }

    /**
     * Title: isEmpty 
     *
     * Description: 判断队列是否为空
     */
    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return false;
    }

    /**
     * Title: clear 
     *
     * Description: 清空队列
     */
    @Override
    public void clear() {
        // TODO Auto-generated method stub
        
    }

}

内部类Node

我决定从底层一步一步实现链式队列，因此，我需要自己定义一个内部类Node，用来实现链结点。代码如下

    class Node<T> {
        private T data;
        private Node<T> next;
        public Node() {
            super();
        }
        public Node(T newEntry) {
           this(newEntry,null);
        }
        public Node(T data, Node next) {
            super();
            this.data = data;
            this.next = next;
        }
        // getter,setter方法
    }

链式队列的字段和构造器。

我们先考虑链式队列需要的节点数，很明显，我们需要一个指向头结点的引用，便于我们删除队列头的元素，也需要一个指向尾结点的引用，便于我们新增元素。于是我们添加以下代码进入LinkedQueue中。

    //字段，因为要保留内部实现权利，所以不准提供getter和setter
    private Node<T> first;
    private Node<T> last;

    // 构造方法，在其中初始化指向首尾结点的引用.
    public LinkedQueue() {
        first = null;
        last = null;
    }

所有方法的实现

    /**
     * Title: enqueue
     *
     * Description: 队列尾部新增元素 newEntry
     */
    @Override
    public void enqueue(T newEntry) {
        Node newNode = new Node<T>(newEntry);
        if (isEmpty()) { // 队列为空时
            first = newNode;
        } else {
            last.setNext(newNode); // 不为空时，我们将其与尾结点链接
        }
        // 指向尾结点的引用后移.
        last = newNode;
    }

    /**
     * Title: dequeue
     *
     * Description: 队列头部删除元素
     */
    @Override
    public T dequeue() {
        if (isEmpty()) {
            // 抛出异常，或者其他逻辑,我这里只是一个打印。
            System.err.println("dequeue() ---> isEmpty()  异常");
            return null;
        }
        T front = first.getData();
        first.setData(null);
        first = first.getNext();
        if (first == null) {
            last = null;
        }
        return front;
    }

    /**
     * Title: getFront
     *
     * Description: 得到头部元素，同peek()
     * 
     */
    @Override
    public T getFront() {
        if (isEmpty()) {
            // 抛出异常，或者其他逻辑,我这里只是一个打印。
            System.err.println("getFront() ---> isEmpty()  异常");
            return null;
        }
        return first.getData();
    }

    /**
     * Title: isEmpty
     *
     * Description: 判断队列是否为空
     */
    @Override
    public boolean isEmpty() {
        return (first == null) && (last == null);
    }

    /**
     * Title: clear
     *
     * Description: 清空队列
     */
    @Override
    public void clear() {
        first = null;
        last = null;
        // GC 会帮我们回收掉内存，我们只需要将这两个引用置为null，GC就明白你不再使用这一整条链了。
    }

链式队列的全部源码

/**
 * Description: 链式结构实现队列
 *
 * @ClassName: LinkedQueue
 * @author 过道
 * @date 2018年8月13日 下午3:18:18
 */
public class LinkedQueue<T> implements QueueInterface<T> {
    // 字段，因为要保留内部实现权利，所以不准提供getter和setter
    private Node<T> first;
    private Node<T> last;

    // 构造方法，在其中初始化指向首尾结点的引用.
    public LinkedQueue() {
        first = null;
        last = null;
    }

    /**
     * Title: enqueue
     *
     * Description: 队列尾部新增元素 newEntry
     */
    @Override
    public void enqueue(T newEntry) {
        Node newNode = new Node<T>(newEntry);
        if (isEmpty()) { // 队列为空时
            first = newNode;
        } else {
            last.setNext(newNode); // 不为空时，我们将其与尾结点链接
        }
        // 指向尾结点的引用后移.
        last = newNode;
    }

    /**
     * Title: dequeue
     *
     * Description: 队列头部删除元素
     */
    @Override
    public T dequeue() {
        if (isEmpty()) {
            // 抛出异常，或者其他逻辑,我这里只是一个打印。
            System.err.println("dequeue() ---> isEmpty()  异常");
            return null;
        }
        T front = first.getData();
        first.setData(null);
        first = first.getNext();
        if (first == null) {
            last = null;
        }
        return front;
    }

    /**
     * Title: getFront
     *
     * Description: 得到头部元素，同peek()
     * 
     */
    @Override
    public T getFront() {
        if (isEmpty()) {
            // 抛出异常，或者其他逻辑,我这里只是一个打印。
            System.err.println("getFront() ---> isEmpty()  异常");
            return null;
        }
        return first.getData();
    }

    /**
     * Title: isEmpty
     *
     * Description: 判断队列是否为空
     */
    @Override
    public boolean isEmpty() {
        return (first == null) && (last == null);
    }

    /**
     * Title: clear
     *
     * Description: 清空队列
     */
    @Override
    public void clear() {
        first = null;
        last = null;
        // GC 会帮我们回收掉内存，我们只需要将这两个引用置为null，GC就明白你不再使用这一整条链了。
    }

    /**
     * 
     * Description: 链式实现队列所必须的结点。
     *
     * @ClassName: Node
     */
    class Node<T> {
        private T data;
        private Node<T> next;
        public Node() {
            super();
        }
        public Node(T newEntry) {
            this(newEntry, null);
        }
        public Node(T data, Node next) {
            super();
            this.data = data;
            this.next = next;
        }
        // getter,setter方法
        public T getData() {
            return data;
        }
        public void setData(T data) {
            this.data = data;
        }
        public Node<T> getNext() {
            return next;
        }
        public void setNext(Node<T> next) {
            this.next = next;
        }
    }
}

数组队列、循环队列

先写一个ArrayQueue实现QueueInterface接口.

/**
 * Description: 数组实现循环队列。
 *
 * @ClassName: ArrayQueue
 * @author 过道
 * @date 2018年8月13日 下午2:10:13
 */
public class ArrayQueue<T> implements QueueInterface<T> {

    /**
     * Description: enqueue
     */
    @Override
    public void enqueue(T newEntry) {
        // TODO Auto-generated method stub
        
    }

    /**
     * Description: dequeue
     */
    @Override
    public T dequeue() {
        // TODO Auto-generated method stub
        return null;
    }

    /**
     * Description: getFront
     */
    @Override
    public T getFront() {
        // TODO Auto-generated method stub
        return null;
    }

    /**
     * Description: isEmpty
     */
    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return false;
    }

    /**
     * Description: clear 
     */
    @Override
    public void clear() {
        // TODO Auto-generated method stub
        
    }
}

数组实现，我们需要添加的字段较多，构造器较为简单,

    private T[] queue;
    private int frontIndex; // 队首
    private int lastIndex; // 队尾
    // 如果调用者没有传入容量，则使用默认容量
    private static final int DEFAULT_CAPACIY = 50;

    public ArrayQueue(int initCapacity) {
        T[] tempQueue = (T[]) new Object[initCapacity + 1]; // 为了方便起见，a[0]不会使用，所以 +1，保持容量不变。
        frontIndex = 0;
        lastIndex = initCapacity;
    }

    // 默认构造器
    public ArrayQueue() {
        this(DEFAULT_CAPACIY);
    }

实现接口中的各个方法

    /**
     * Title: enqueue
     *
     * Description: enqueue
     */
    @Override
    public void enqueue(T newEntry) {
        // 确保容量够用s
        ensureCapacity();
        backIndex = (backIndex + 1) % queue.length;
        queue[backIndex] = newEntry;
    }

    /**
     * Description:
     *
     * @Title: ensureCapacity void
     */
    private void ensureCapacity() {
        // 如果发现数组容量被使用完，申请一个双倍size的数组进行替换。
        if (frontIndex == (backIndex + 2) % queue.length) {
            T[] oldQueue = queue;
            int oldSize = oldQueue.length;
            int newSize = oldSize * 2;      // 容量翻倍
            
            @SuppressWarnings("unchecked")
            T[] tempQueue = (T[]) new Object[newSize];
            for (int i = 0; i < tempQueue.length; i++) {
                tempQueue[i] = oldQueue[frontIndex];
                frontIndex = (frontIndex + 1) % oldSize;
            }
            // 再次初始化首尾
            frontIndex = 0;
            backIndex = oldSize - 1;
        }
    }

    /**
     * Title: dequeue
     *
     * Description: 删除头部元素
     */
    @Override
    public T dequeue() {
        if (isEmpty()) {
            // 抛出异常
        }
        T front = queue[frontIndex];
        queue[frontIndex] = null;
        frontIndex = (frontIndex + 1) % queue.length;
        return front;
    }

    /**
     * Title: getFront
     *
     * Description: getFront
     */
    @Override
    public T getFront() {
        if (isEmpty()) {
            // 抛出异常，
        }
        return queue[frontIndex];
    }

    /**
     * Title: isEmpty
     *
     * Description: isEmpty
     */
    @Override
    public boolean isEmpty() {
        return frontIndex == (backIndex + 1) % queue.length;
    }

    /**
     * Title: clear
     *
     * Description: clear
     */
    @Override
    public void clear() {
        while (!isEmpty()) {
            dequeue();
        }
    }

循环数组实现的所有源码

package unit10.queueBlog;

import unit10.queue.QueueInterface;

/**
 * Description: 数组实现循环队列。
 *
 * @ClassName: ArrayQueue
 * @author 过道
 * @date 2018年8月13日 下午2:10:13
 */
public class ArrayQueue<T> implements QueueInterface<T> {
    private T[] queue;
    private int frontIndex; // 队首
    private int backIndex; // 队尾
    // 如果调用者没有传入容量，则使用默认容量
    private static final int DEFAULT_CAPACIY = 50;

    public ArrayQueue(int initCapacity) {
        T[] tempQueue = (T[]) new Object[initCapacity + 1]; // 为了方便识别，保留一个位置不被使用，所以 size +1。
        frontIndex = 0;
        backIndex = initCapacity;
    }
    // 默认构造器
    public ArrayQueue() {
        this(DEFAULT_CAPACIY);
    }
    /**
     * Title: enqueue
     *
     * Description: enqueue
     */
    @Override
    public void enqueue(T newEntry) {
        // 确保容量够用s
        ensureCapacity();
        backIndex = (backIndex + 1) % queue.length;
        queue[backIndex] = newEntry;
    }
    /**
     * Description:
     *
     * @Title: ensureCapacity void
     */
    private void ensureCapacity() {
        // 如果发现数组容量被使用完，申请一个双倍size的数组进行替换。
        if (frontIndex == (backIndex + 2) % queue.length) {
            T[] oldQueue = queue;
            int oldSize = oldQueue.length;
            int newSize = oldSize * 2;      // 容量翻倍
            
            @SuppressWarnings("unchecked")
            T[] tempQueue = (T[]) new Object[newSize];
            for (int i = 0; i < tempQueue.length; i++) {
                tempQueue[i] = oldQueue[frontIndex];
                frontIndex = (frontIndex + 1) % oldSize;
            }
            // 再次初始化首尾
            frontIndex = 0;
            backIndex = oldSize - 1;
        }
    }
    /**
     * Title: dequeue
     *
     * Description: 删除头部元素
     */
    @Override
    public T dequeue() {
        if (isEmpty()) {
            // 抛出异常
        }
        T front = queue[frontIndex];
        queue[frontIndex] = null;
        frontIndex = (frontIndex + 1) % queue.length;
        return front;
    }
    /**
     * Title: getFront
     *
     * Description: getFront
     */
    @Override
    public T getFront() {
        if (isEmpty()) {
            // 抛出异常，
        }
        return queue[frontIndex];
    }
    /**
     * Title: isEmpty
     *
     * Description: isEmpty
     */
    @Override
    public boolean isEmpty() {
        return frontIndex == (backIndex + 1) % queue.length;
    }
    /**
     * Title: clear
     *
     * Description: clear
     */
    @Override
    public void clear() {
        while (!isEmpty()) {
            dequeue();
        }
    }
}

使用java 自身的类库实现队列的集中方式.

使用linkedList实现Queue(),

public class LinkedQueue<T> implements QueueInterface<T> {
    private LinkedList<T> list;

    public LinkedQueue() {
        list = new LinkedList<T>();
    }

    @Override
    public void enqueue(T newEntry) {
        list.addLast(newEntry);
    }

    @Override
    public T dequeue() {
        // 移除首位
        return list.removeFirst();
    }

    @Override
    public T getFront() {
        return list.getFirst();
    }

    @Override
    public boolean isEmpty() {
        // 或者 list.size() == 0
        return list.isEmpty();
    }

    @Override
    public void clear() {
        while (!isEmpty()) {
            list.remove();
        }
    }

}

Java类库：类AbstractQueue

Java 类库的标准包java.util含有抽象类AbstractQueue.这个类实现了接口java.util,Queue,且不允许队列中含有null值。

这里只是将java源码删除注释后搬运过来，方便查看它拥有的方法.

public abstract class AbstractQueue<E> extends AbstractCollection<E>
    implements Queue<E> {

    protected AbstractQueue() {
    }

    public boolean add(E e) {
        if (offer(e))
            return true;
        else
            throw new IllegalStateException("Queue full");
    }

    public E remove() {
        E x = poll();
        if (x != null)
            return x;
        else
            throw new NoSuchElementException();
    }


    public E element() {
        E x = peek();
        if (x != null)
            return x;
        else
            throw new NoSuchElementException();
    }
    public void clear() {
        while (poll() != null)
            ;
    }
    public boolean addAll(Collection<? extends E> c) {
        if (c == null)
            throw new NullPointerException();
        if (c == this)
            throw new IllegalArgumentException();
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }
//以下为父类继承出来的方法，搬运到一起方便学习
    public boolean isEmpty() {
        return size() == 0;
    }
    public boolean contains(Object o) {
        Iterator<E> it = iterator();
        if (o==null) {
            while (it.hasNext())
                if (it.next()==null)
                    return true;
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return true;
        }
        return false;
    } 
    public Object[] toArray() {
        // Estimate size of array; be prepared to see more or fewer elements
        Object[] r = new Object[size()];
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) // fewer elements than expected
                return Arrays.copyOf(r, i);
            r[i] = it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r;
    }
}