Java中队列

定义

队的操作是在两端进行,一端只能进行插入操作(入队),称为队尾,一端只能进行删除操作(出队),称为队尾。

队列的运算规则是FIFO(first in first out)。

队列的入队、出队操作分别具有入队和出队的指针,通常以f(front) 表示队首指针,r(rear)表示队尾指针。

队列的存储具有顺序存储和链式存储两种方式。

基本运算:

  • 初始化;
  • 判断空;
  • 判断满;
  • 入队;
  • 出队;
  • 取出队首元素。
package com.wuwii.test;

/**
 * 队列
 * @author Zhang Kai
 * @version 1.0
 * @since <pre>2017/12/17 13:12</pre>
 */
public interface Queue<E> {
    /**
     * 入队
     * @param element 入队元素
     */
    void enqueue(E element);

    /**
     * 出队第一个元素
     * @return 第一个元素
     */
    E dequeue();

    /**
     * 返回队首的元素
     * @return E 队首元素
     */
    E frontValue();

    /**
     * 清空队列的所有元素
     */
    void clear();

    /**
     * 判断队列是否为空
     * @return true 为空,
     */
    Boolean isEmpty();

}

顺序队列

。由于顺序存储结构的空间是连续的,需要一个向量空间存储当前队列的所有元素,由于队列的对头和队尾的位置是变化的。初始化的时候,rear 和front 都设置为 0 ;入队的时候将新元素插入rear 所指的位置,然后将rear 加 1 ;出队的时候,删除 front 所指的元素,然后将 front 加 1并返回该元素。由此可见,当头尾指针相等时队列为空。在非空队列中,头指针始终指向队头元素,而尾指针始终指向队尾元素的下个位置。

这里其实存在一个问题需要解决。队列的顺序存储结构同样也存在上溢和下溢的问题。而且,队列中还存在假溢出现象,指的是队列在入队和出队的操作中,头尾指针不断增加而不减少或者只减少而不增加,导致被删除的元素的空间无法重新利用,因此,尽管队列中实际的元素个数远远小于向量空间的规模,但也可能由于尾指针已远远超越向量空间的上界而不能进行入队或出队的操作,这种现象称为假上溢。

解决假上溢有多种方法。

  • 固定头指针:固定队首指针,一旦删除元素,需要移动所有元素,然后修改队尾指针,这样就又可以插入元素,只有在不能插入元素的时候,队列才是满的,否则可以一直插入元素,但是也存在一个,每次删除元素的时候,都移动了大量的数据,造成性能损失;
  • 循环向量:存储在循环向量的队列成为循环队列。

循环队列

存储在循环向量的队列成为循环队列

假设向量的空间为m,只要在入队或者出队操作的时候,将队首和队尾的指针对m做求模运算即可实现队首和队尾指针的循环,因此,队首和队尾指针的数值取值范围为0 ~ m-1 之间。

入队时:rear = (rear + 1) % maxSize;

出队时:front = (front + 1) % maxSize;

入队时,rear指针不断加一,知道rear 指针追上 front 指针的时候,队列满,rear = front,出队的时候,只需要判断 front = rear。因此,又出现了一个问题,判断队列的空与满的条件相同。

区分队列的空与满:

  • 方式一:浪费一个空间;rear指向刚刚插入的位置,front指向刚刚插入的位置;入队的时候先不修改rear 指针,先去判断(rear + 1) % maxSize = front,成立,表示队列已经满了。出队的时候只需要判断 front = rear,不为空的话,删除front = (front + 1) % maxSize位置的元素。
  • 方式二:设定一个变量来保存存储的元素个数;将该变量跟队列最大容量进行比较,如果相等,则队列满,如果该变量为0,表示队列为空。

上面两种方式都需要消费一个存储单元。

实现循环队列需要两个指针的开销,需要定义数组的最大下标范围,遵循先进先出原则。

package com.wuwii.test;

/**
 * 顺序队列 -》循环队列
 * @author Zhang Kai
 * @version 1.0
 * @since <pre>2017/12/17 13:17</pre>
 */
public class Squeue<E> implements Queue<E> {
    /**
     * 队列默认大小
     */
    private final int defaultSize = 10;
    /**
     * 队列存储的元素个数
     */
    private int size;
    /**
     * 队首位置
     */
    private int front;
    /**
     * 队尾位置
     */
    private int rear;
    /**
     * 存储数组
     */
    private Object[] elements;

    /**
     * 无参构造,使用默认大小10
     */
    public Squeue() {
        initQueue(defaultSize);
    }

    /**
     * 有参构造,指定队列大小
     * @param givenSize 需要指定队列大小
     */
    public Squeue(int givenSize) {
        initQueue(givenSize);
    }
    /**
     * 入队
     *
     * @param element 入队元素
     */
    @Override
    public void enqueue(E element) {
        checkFull();
        rear = (rear + 1) % size;
        elements[rear] = element;
    }

    /**
     * 出队第一个元素
     *
     * @return 第一个元素
     */
    @Override
    public E dequeue() {
        checkEmpty();
        front = (front + 1) % size;
        return (E) elements[front];
    }

    /**
     * 返回队首的元素
     *
     * @return E 队首元素
     */
    @Override
    public E frontValue() {
        return (E) elements[(front + 1) % size];
    }

    /**
     * 清空队列的所有元素
     */
    @Override
    public void clear() {
        if (isEmpty()) {
            return;
        }
        front = rear = 0;
    }

    /**
     * 判断队列是否为空
     *
     * @return true 为空,
     */
    @Override
    public Boolean isEmpty() {
        return front == rear;
    }

    /**
     * 初始化队列
     * @param givenSize 给定大小
     */
    private void initQueue(int givenSize) {
        size = givenSize + 1;
        front = rear = 0;
        elements = new Object[size];
    }

    /**
     * 检查队列满
     * 队列满了抛出异常
     */
    private void checkFull() {
        if (front == (rear + 1) % size) {
            throw new RuntimeException("Queue is full");
        }
    }

    /**
     * 检查队列为空
     * 为空抛出异常
     */
    private void checkEmpty() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
    }
}

链式队列

相比顺序队列,链式队列的队首和队尾改为指针。

链式队列存在一个很方便的特点,只需要一个队尾指针就可以完成队列所有的基本运算,主要原因就是队列的运算方式时先进先出,已知一个任意节点,就可以查找出所有,所以只需要一个队尾就可以了,节约空间开销。

清空队列只需要将指针删除即可。

package com.wuwii.test;

/**
 * 链式队列,循环队列
 * @author Zhang Kai
 * @version 1.0
 * @since <pre>2017/12/17 14:14</pre>
 */
public class LinkQueue<E> implements Queue<E> {
    /**
     * 队首指针
     */
    private Node<E> front;
    /**
     * 队尾指针
     */
    private Node<E> rear;

    public LinkQueue() {
        initQueue();
    }

    /**
     * 入队
     *
     * @param element 入队元素
     */
    @Override
    public void enqueue(E element) {
        if (rear == null) {
            rear = new Node<>(null, element);
        } else {
            front = rear = new Node<>(null, element);
        }
    }

    /**
     * 出队第一个元素
     *
     * @return 第一个元素
     */
    @Override
    public E dequeue() {
        checkEmpty();
        E e = front.element;
        front = front.next;
        return e;
    }

    /**
     * 返回队首的元素
     *
     * @return E 队首元素
     */
    @Override
    public E frontValue() {
        return front.element;
    }

    /**
     * 清空队列的所有元素
     */
    @Override
    public void clear() {
        front = rear = null;
    }

    /**
     * 判断队列是否为空
     *
     * @return true 为空,
     */
    @Override
    public Boolean isEmpty() {
        return rear == null;
    }

    /**
     * 存储单元,链表单元
     * @param <E>
     */
    private static class Node<E> {
        Node<E> next;
        E element;
        Node(Node<E> next, E element) {
            this.next = next;
            this.element = element;
        }
    }

    /**
     * 初始化队列
     */
    private void initQueue() {
        front = rear = null;
    }
    /**
     * 检查队列为空
     * 为空抛出异常
     */
    private void checkEmpty() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
    }
}

原文地址:https://www.cnblogs.com/qnight/p/8983142.html

时间: 2024-10-09 20:25:09

Java中队列的相关文章

Java 中队列的使用

刚才看见群里的一个朋友在问队列的使用,确实在现实的写代码中非常少使用队列的,反正我是从来没使用过.仅仅是学数据结构的时候学过. 以下是我写的一个小样例,希望有不足之处请提出改正.O(∩_∩)O~ 看代码: import java.util.LinkedList; import java.util.Queue; public class TestQueue { /** * @param args * @author JavaAlpha * Info 測试队列 */ public static vo

java中队列Queue的使用

1.在java5中新增加了java.util.Queue接口,用以支持队列的常见操作.Queue接口与List.Set同一级别,都是继承了Collection接口.Queue使用时要尽量避免Collection的add()和remove()方法,而是要使用offer()来加入元素,使用poll()来获取并移出元素.它们的优点是通过返回值可以判断成功与否,add()和remove()方法在失败的时候会抛出异常. 如果要使用前端而不移出该元素,使用element()或者peek()方法. 2.值得注

java中队列实现

队列的定义: 队列(Queue)是只允许在一端进行插入,而在另一端进行删除的运算受限的线性表. (1)允许删除的一端称为队头(Front). (2)允许插入的一端称为队尾(Rear).(3)当队列中没有元素时称为空队列.(4)队列亦称作先进先出(First In First Out)的线性表,简称为FIFO表.   队列的修改是依先进先出的原则进行的.新来的成员总是加入队尾,每次离开的成员总是队列头上的(不允许中途离队). 队列的存储结构及实现 队列的顺序存储结构 (1) 顺序队列的定义: 队列

JAVA线程池中队列与池大小的关系

JAVA线程中对于线程池(ThreadPoolExecutor)中队列,池大小,核心线程的关系写出自己的理解: 1:核心线程:简单来讲就是线程池中能否允许同时并发运行的线程的数量 2:线程池大小:线程池中最多能够容纳的线程的数量. 3:队列:对提交过来的任务的处理模式. 对于线程池与队列的交互有个原则: 如果队列发过来的任务,发现线程池中正在运行的线程的数量小于核心线程,则立即创建新的线程,无需进入队列等待.如果正在运行的线程等于或者大于核心线程,则必须参考提交的任务能否加入队列中去. 1:提交

java中使用FIFO队列:java.util.Queue实现多台服务器发邮件的代码

代码下载地址:http://www.zuidaima.com/share/1838230785625088.htm 原文:java中使用FIFO队列:java.util.Queue实现多台服务器发邮件的代码 最近由于zuidaima.com注册用户的增多,qq企业邮箱发送邮件会被封禁账号导致注册后面的用户收不到周总结,所以紧急开发了一套多账号,多服务器发送邮件的程序. 大概的设计思路如下: 1.服务器可以无限扩展,但由于qq企业邮箱是限定域名,所以要想多服务器还得有多域名,多账号也不行. 2.最

Java中的自定义数组队列

在Java中,作为所有数据结构中存储和获取速度最快的一种,数组凭借其这种简单易用的优势在各个方面都能大显神威.但是数组也有自身的局限性.数组的长度必须是固定的一旦定义之后就无法动态的更改,这就会造成这样的问题,如果数组已满,就无法继续添加数据(当然你可以定义一个"足够大的数组",但问题是多大才是足够大呢?太小不够,太大浪费内存空间).如果删除一个数据,它的内存空间空着没有被使用.另外数组只能存储同一类型的数据,如果把它设置成Object类型的话,是可以存不同类型的数据了,但是设想这样一

Java中,将ResultSet映射为对象和队列及其他辅助函数

关于对象关系映射(ORM)在数据库访问中用到的最多,在Java中,很多库都试图将一个ResultSet映射为一个自定义的Java Bean对象或队列,下面是我的实现 1 从ResultSet中读取数据 首先是,如何能正确的从ResultSet中读取到自己想要的数据,包括已知列序号和已知列名的情况. 已知列序号,读取ResultSet中的数据值: public static <T> T ReadValue(Class<T> t, ResultSet set, int columnIn

多线程编程学习六(Java 中的阻塞队列).

介绍 阻塞队列(BlockingQueue)是指当队列满时,队列会阻塞插入元素的线程,直到队列不满:当队列空时,队列会阻塞获得元素的线程,直到队列变非空.阻塞队列就是生产者用来存放元素.消费者用来获取元素的容器. 当线程 插入/获取 动作由于队列 满/空 阻塞后,队列也提供了一些机制去处理,或抛出异常,或返回特殊值,或者线程一直等待... 方法/处理方式 抛出异常 返回特殊值 一直阻塞 超时退出 插入方法 add(e) offer(e) put(e) offer(e, timeout, unit

Java中的软(弱)引用

一.Java中的强.软.弱.虚引用 在JDK中我们可以看到有一个java.lang.ref的包,这个包中就是Java中实现强.软.弱.虚引用的包,如下: PhantomReference 虚引用:如果一个对象持有虚引用,就和没有持有引用一样,在任何时候都可能被垃圾回收器回收.虚引用主要用来跟踪对象被垃圾回收的活动,虚引用还有一个和弱.软引用不同的地方是虚引用必须和引用队列联合使用.当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象内存之前,把这个虚引用加入到与之关联的引用队列中