数据结构实现（二）队列

1、队列的顺序存储结构实现

package dataStructures;

public class QueueArray<E> {
    private Object[] data = null;
    private int maxSize; // 队列容量
    private int head; // 队列头，允许删除
    private int tail; // 队列尾，允许插入

    // 构造函数
    public QueueArray() {
        this(10);
    }

    public QueueArray(int initialSize) {
        if (initialSize >= 0) {
            this.maxSize = initialSize;
            data = new Object[initialSize];
            head = tail = 0;
        } else {
            throw new RuntimeException("初始化大小不能小于0：" + initialSize);
        }
    }

    // 判空
    public boolean empty() {
        return tail == head ? true : false;
    }

    // 插入
    public boolean add(E e) {
        if (tail == maxSize) {
            throw new RuntimeException("队列已满，无法插入新的元素！");
        } else {
            data[tail++] = e;
            return true;
        }
    }

    // 返回队首元素，但不删除
    public E peek() {
        if (empty()) {
            throw new RuntimeException("空队列异常！");
        } else {
            return (E) data[head];
        }
    }

    // 出队
    public E poll() {
        if (empty()) {
            throw new RuntimeException("空队列异常！");
        } else {
            E value = (E) data[head]; // 保留队列的head端的元素的值
            data[head++] = null; // 释放队列的head端的元素
            return value;
        }
    }

    // 队列长度
    public int length() {
        return tail - head;
    }
}

2、循环队列的顺序存储结构实现

package dataStructures;

import java.util.Arrays;

public class QueueArray2<E> {
    public Object[] data = null;
    private int maxSize; // 队列容量
    private int tail;// 队列尾，允许插入
    private int head;// 队列头，允许删除
    private int size = 0; // 队列当前长度

    public QueueArray2() {
        this(10);
    }

    public QueueArray2(int initialSize) {
        if (initialSize >= 0) {
            this.maxSize = initialSize;
            data = new Object[initialSize];
            head = tail = 0;
        } else {
            throw new RuntimeException("初始化大小不能小于0：" + initialSize);
        }
    }

    // 判空
    public boolean empty() {
        return size == 0;
    }

    // 插入
    public boolean add(E e) {
        if (size == maxSize) {
            throw new RuntimeException("队列已满，无法插入新的元素！");
        } else {
            data[tail] = e;
            tail = (tail + 1) % maxSize;
            size++;
            return true;
        }
    }

    // 返回队首元素，但不删除
    public E peek() {
        if (empty()) {
            throw new RuntimeException("空队列异常！");
        } else {
            return (E) data[head];
        }
    }

    // 出队
    public E poll() {
        if (empty()) {
            throw new RuntimeException("空队列异常！");
        } else {
            E value = (E) data[head]; // 保留队列的head端的元素的值
            data[head] = null; // 释放队列的head端的元素
            head = (head + 1) % maxSize; // 队首指针加1
            size--;
            return value;
        }
    }

    // 队列长度
    public int length() {
        return size;
    }

    // 清空循环队列
    public void clear() {
        Arrays.fill(data, null);
        size = 0;
        head = 0;
        tail = 0;
    }
}

3、队列的链式存储结构实现

package dataStructures;

public class QueueLink<E> {
    // 链栈的节点
    private class Node<E> {
        E e;
        Node<E> next;

        public Node() {
        }

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }
    }

    private Node head;// 队列头，允许删除
    private Node tail;// 队列尾，允许插入
    private int size; // 队列当前长度

    public QueueLink() {
        head = null;
        tail = null;
    }

    // 判空
    public boolean empty() {
        return size == 0;
    }

    // 插入
    public boolean add(E e) {
        if (empty()) { // 如果队列为空
            head = new Node(e, null);// 只有一个节点，head、tail都指向该节点
            tail = head;
        } else {
            Node<E> newNode = new Node<E>(e, null);
            tail.next = newNode; // 让尾节点的next指向新增的节点
            tail = newNode; // 以新节点作为新的尾节点
        }
        size++;
        return true;
    }

    // 返回队首元素，但不删除
    public Node<E> peek() {
        if (empty()) {
            throw new RuntimeException("空队列异常！");
        } else {
            return head;
        }
    }

    // 出队
    public Node<E> poll() {
        if (empty()) {
            throw new RuntimeException("空队列异常！");
        } else {
            Node<E> temp = head; // 得到队列头元素
            head = head.next;// 让head引用指向原队列头元素的下一个元素
            temp.next = null; // 释放原队列头元素的next引用
            size--;
            return temp;
        }
    }

    // 队列长度
    public int length() {
        return size;
    }
}

4、基于LinkedList实现队列结构

package dataStructures;

/**
 * 使用java.util.Queue接口,其底层关联到一个LinkedList（双端队列）实例.
 */
import java.util.LinkedList;
import java.util.Queue;

public class QueueLinkedList<E> {
    private Queue<E> queue = new LinkedList<E>();

    // 将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 true，
    // 如果当前没有可用的空间，则抛出 IllegalStateException。
    public boolean add(E e) {
        return queue.add(e);
    }

    // 获取，但是不移除此队列的头。
    public E element() {
        return queue.element();
    }

    // 将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，
    // 此方法通常要优于 add(E)，后者可能无法插入元素，而只是抛出一个异常。
    public boolean offer(E e) {
        return queue.offer(e);
    }

    // 获取但不移除此队列的头；如果此队列为空，则返回 null
    public E peek() {
        return queue.peek();
    }

    // 获取并移除此队列的头，如果此队列为空，则返回 null
    public E poll() {
        return queue.poll();
    }

    // 获取并移除此队列的头
    public E remove() {
        return queue.remove();
    }

    // 判空
    public boolean empty() {
        return queue.isEmpty();
    }
}

转载：https://www.cnblogs.com/CherishFX/p/4608880.html