数据结构—队列(Queue)的原理以及Java实现案例

刘Java
944 阅读7分钟

「这是我参与11月更文挑战的第15天，活动详情查看：2021最后一次更文挑战」。

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。本文详细介绍了队列的特性，并且使用Java语言分别实现了基于顺序结构和链式结构的队列。

1 队列的概述

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列的工作原理与现实生活中的队列完全相同。假设你与朋友一起在公交车站排队，如果你排在他前面，你将先上车，而后来的人将会排在你朋友后面。队列的工作原理与此相同。

队列是一种先进先出（First In First Out）的线性表，简称FIFO。 允许插入的一端称为队尾，允许删除的一端称为队头。假设队列是q=(a1,a2,......,an)，那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，列在最后。

在这里插入图片描述

因为队列属于线性表，因此队列也可以采用顺序存储结构和链式存储结构来实现。Java中已经提供了很多线程的队列的实现，比如JUC中的各种阻塞、非阻塞队列。在生产环境中，各种消息队列比如kafka底层都使用了最基本的队列的特性。队列的使用频率是要高于栈的。

关于Java 栈的数据结构，可以看这篇文章：数据结构—栈(Stack)的原理以及Java实现以及后缀表达式的运算。

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

2.1 队列的顺序存储结构概述

和栈不同的是，队列的入队和出队操作在不同端。采用数组来实现时，如果和实现栈的思想一样，如果队头在数组元素最大索引处，那么入队列就是将元素添加到最大索引后的索引处，不需要移动元素，此时时间复杂度为Ｏ(1)；但是出队列就要在数组头部了，此时将会移动全部元素，时间复杂度为O(n)。如果队头在数组元素的起始索引处，那么出队列到时变快了，但是入队列的时间复杂度却又变成O(n)了。

因此，这里要灵活处理对头或者队尾，不再是固定在数组起始索引或者最大索引处，应该是可变的，此时需要添加外部指针用来保存“队头”和“队尾”。操作数据的时候只需要操作队头和队尾就行了，这样入队和出队的时间复杂度都是O(1)。

按照上面的做法，队头和队尾是不用固定了，入队和出队操作确实很方便。但是可能造成索引溢出以及内存浪费，如下图：

在这里插入图片描述

可能会出现图上的情况，队头被移动到数组的中间，而队尾由于添加元素，移动到数组尾部，此时如果再次入队，由于数组索引溢出将会抛出ArrayIndexOutOfBoundsException，但是数组的前半部分空间却还没有使用，此时又造成了空间浪费。

上面这种溢出，称为“假溢出”。假溢出的办法就是后面满了，就再从头开始，也就是头尾相接的循环。我们把队列的这种头尾相接的顺序存储结构称为循环队列。

循环队列解决了假溢出的问题，同时入队和出队时间都是O(1)。此时需要考虑的就只是数组的容量有限的问题了。

2.2 数组循环队列的简单实现

/**
 * 数组实现的循环队列,为了方便,这里底层数组设计为不可扩展
 */
public class MyArrayLoopQueue<E> {

    /**
     * 采用数组实现链式存储
     */
    private final Object[] elements;

    /**
     * 容量
     */
    private final int capacity;

    /**
     * 队头元素索引
     */
    private int first;

    /**
     * 队尾元素索引
     */
    private int end;

    /**
     * 元素个数
     */
    private int size;

    /**
     * 构造器初始化数组
     *
     * @param capacity 容量
     */
    public MyArrayLoopQueue(int capacity) {
        this.capacity = capacity;
        this.elements = new Object[capacity];
    }


    /**
     * 入队,元素添加在队尾
     *
     * @param element 添加的元素
     * @return 添加成功返回true，添加失败返回false
     */
    public boolean add(E element) {
        //如果队列容量已满.添加失败返回false
        if (size == capacity) {
            return false;
        }
        if (size == 0) {
            /*如果是第一次放元素,则队头和队尾都指向索引0处的元素*/
            elements[end] = element;
        } else if (end + 1 == capacity) {
            /*如果end + 1等于capacity说明队尾空间满了，转向队头,队尾队尾索引置0，循环*/
            end = 0;
            elements[end] = element;
        } else {
            /*否则,队尾索引正常自增*/
            elements[++end] = element;
        }
        //size自增1
        size++;
        return true;
    }

    /**
     * 出队,删除队头元素
     *
     * @return 被移除的元素, 或者null
     */
    public E remove() {
        //队列是否已空
        if (size == 0) {
            // 返回null
            return null;
        }
        Object o = elements[first];
        //移除队头元素
        elements[first] = null;
        //如果队头索引+1之后等于capacity，重置队头索引，循环
        if (++first == capacity) {
            first = 0;
        }
        //如果出队列后队列为空,那么重置队头和队尾索引
        if (--size == 0) {
            first = 0;
            end = 0;
        }
        return (E) o;
    }

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


    /**
     * 清空队列
     */
    public void clear() {
        for (int i = 0; i < size; i++) {
            elements[i] = null;
        }
        size = 0;
        first = 0;
        end = 0;
    }


    /**
     * 重写了toString方法
     *
     * @return
     */
    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        if (size == 0) {
            stringBuilder.append("[ ]");
            return stringBuilder.toString();
        }
        stringBuilder.append("[ ");
        if (first < end) {
            for (int i = first; i <= end; i++) {
                stringBuilder.append(elements[i]);
                if (i != end) {
                    stringBuilder.append(", ");
                }
            }
        } else if (size == 1) {
            stringBuilder.append(elements[first]);
        } else {
            for (int i = first; i < capacity; i++) {
                stringBuilder.append(elements[i]);
                stringBuilder.append(", ");
            }
            for (int i = 0; i <= end; i++) {
                stringBuilder.append(elements[i]);
                if (i != end) {
                    stringBuilder.append(", ");
                }
            }
        }
        stringBuilder.append(" ]");
        return stringBuilder.toString();
    }


    /**
     * 增强toString方法,用于测试
     *
     * @return
     */
    public String toStringPlus() {
        StringBuilder stringBuilder = new StringBuilder();
        if (size == 0) {
            stringBuilder.append("[ ]");
            stringBuilder.append(" ; first:").append(first).append(" ; end:").append(end).append(" ; size:").append(size);
            return stringBuilder.toString();
        }
        stringBuilder.append("[ ");
        if (first < end) {
            for (int i = first; i <= end; i++) {
                stringBuilder.append(elements[i]);
                if (i != end) {
                    stringBuilder.append(", ");
                }
            }
        } else if (size == 1) {
            stringBuilder.append(elements[first]);
        } else {
            for (int i = first; i < capacity; i++) {
                stringBuilder.append(elements[i]);
                stringBuilder.append(", ");
            }
            for (int i = 0; i <= end; i++) {
                stringBuilder.append(elements[i]);
                if (i != end) {
                    stringBuilder.append(", ");
                }
            }
        }
        stringBuilder.append(" ]");
        stringBuilder.append(" ; first:").append(first).append(" ; end:").append(end).append(" ; size:").append(size);
        return stringBuilder.toString();
    }
}

2.2.1 测试

MyArrayLoopQueue<Object> objectMyArrayLoopQueue = new 
MyArrayLoopQueue<>(4);
System.out.println("入队========>");
objectMyArrayLoopQueue.add(11);
objectMyArrayLoopQueue.add(22);
objectMyArrayLoopQueue.add(33);
System.out.println(objectMyArrayLoopQueue.toStringPlus());

System.out.println("出队========>");
objectMyArrayLoopQueue.remove();
System.out.println(objectMyArrayLoopQueue.toStringPlus());

System.out.println("出队========>");
objectMyArrayLoopQueue.remove();
System.out.println(objectMyArrayLoopQueue.toStringPlus());

System.out.println("入队========>");
objectMyArrayLoopQueue.add(44);
objectMyArrayLoopQueue.add(55);
System.out.println(objectMyArrayLoopQueue.toStringPlus());

System.out.println("入队========>");
objectMyArrayLoopQueue.add(null);
System.out.println(objectMyArrayLoopQueue.toStringPlus());

System.out.println("入队失败========>");
boolean add = objectMyArrayLoopQueue.add(77);
System.out.println(add);
System.out.println(objectMyArrayLoopQueue.toStringPlus());


System.out.println("出队========>");
System.out.println(objectMyArrayLoopQueue.remove());
System.out.println(objectMyArrayLoopQueue.toStringPlus());
System.out.println("出队========>");
System.out.println(objectMyArrayLoopQueue.remove());
System.out.println(objectMyArrayLoopQueue.toStringPlus());
System.out.println("出队========>");
System.out.println(objectMyArrayLoopQueue.remove());
System.out.println(objectMyArrayLoopQueue.toStringPlus());
System.out.println("出队========>");
System.out.println(objectMyArrayLoopQueue.remove());
System.out.println(objectMyArrayLoopQueue.toStringPlus());
System.out.println("出队========>");
System.out.println(objectMyArrayLoopQueue.remove());
System.out.println(objectMyArrayLoopQueue.toStringPlus());

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

3.1 队列的链式存储结构概述

队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，我们把它简称为链队列。为了操作上的方便，我们将队头指针指向链队列的头结点，而队尾指针指向终端结点。

可以看出来，使用链式结构实现队列相比顺序结构的实现更加简单。

3.2 队列的链式存储结构简单实现

/**
 * 队列的链式储存结构的简单单链表实现
 */
public class MySingleLinkedQueue<E> {

    /**
     * 空构造器,内部的节点均没有初始化,在第一次添加时才会初始化。
     */
    public MySingleLinkedQueue() {
    }

    /**
     * 元素个数
     */
    private int size;

    /**
     * 指向队头结点的引用
     */
    private Node<E> first;


    /**
     * 指向队尾结点的引用
     */
    private Node<E> end;

    /**
     * 单链表内部的节点
     */
    private static class Node<E> {
        //下一个结点的引用
        Node<E> next;
        //结点数据
        E data;

        //节点构造器
        public Node(E data, Node<E> next) {
            this.data = data;
            this.next = next;
        }
    }

    /**
     * 入队，添加元素到单链表尾部
     *
     * @param e 要添加的元素
     */
    public void add(E e) {
        //创建新节点
        Node<E> newNode = new Node<>(e, null);
        if (end != null) {
            /*如果尾结点不为空*/
            end.next = newNode;
            //改变队尾节点引用
            end = newNode;
        } else {
            end = newNode;
            first = newNode;
        }
        ++size;
    }

    /**
     * 出队，删除单链表头部元素
     *
     * @return 被删除的元素
     */
    public E remove() {
        //如果头结点为空,抛出异常
        if (first == null) {
            throw new NoSuchElementException("队列已经为空");
        }
        E e = first.data;
        //改变队头节点引用
        first = first.next;
        //如果元素为0,则将队尾节点引用置空
        if (--size == 0) {
            end = null;
        }
        return e;
    }

    /**
     * 获取元素数量
     */
    public int size() {
        return size;
    }


    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        if (size > 0) {
            Node<E> f = first;
            stringBuilder.append("[ ");
            for (int i = 0; i < size; i++) {
                stringBuilder.append(f.data);
                if (i != size - 1) {
                    stringBuilder.append(" , ");
                }
                f = f.next;
            }
            stringBuilder.append(" ]");
            return stringBuilder.toString();
        }
        return "[]";
    }
}

3.2.1 测试

MySingleLinkedQueue<Object> objectMySingleLinkedQueue = new 
MySingleLinkedQueue<>();
System.out.println("入队========>");
objectMySingleLinkedQueue.add(11);
objectMySingleLinkedQueue.add(22);
objectMySingleLinkedQueue.add(33);
System.out.println(objectMySingleLinkedQueue.toString());

System.out.println("出队========>");
objectMySingleLinkedQueue.remove();
System.out.println(objectMySingleLinkedQueue.toString());

System.out.println("出队========>");
objectMySingleLinkedQueue.remove();
System.out.println(objectMySingleLinkedQueue.toString());

System.out.println("入队========>");
objectMySingleLinkedQueue.add(44);
objectMySingleLinkedQueue.add(55);
System.out.println(objectMySingleLinkedQueue.toString());

System.out.println("入队========>");
objectMySingleLinkedQueue.add(null);
System.out.println(objectMySingleLinkedQueue.toString());


System.out.println("出队========>");
System.out.println(objectMySingleLinkedQueue.remove());
System.out.println(objectMySingleLinkedQueue.toString());
System.out.println("出队========>");
System.out.println(objectMySingleLinkedQueue.remove());
System.out.println(objectMySingleLinkedQueue.toString());
System.out.println("出队========>");
System.out.println(objectMySingleLinkedQueue.remove());
System.out.println(objectMySingleLinkedQueue.toString());
System.out.println("出队========>");
System.out.println(objectMySingleLinkedQueue.remove());
System.out.println(objectMySingleLinkedQueue.toString());

System.out.println("出队异常========>");
System.out.println(objectMySingleLinkedQueue.remove());
System.out.println(objectMySingleLinkedQueue.toString());

4 总结

本文介绍了队列的基本概念，并且提供了简单的实现，队列属于一种特殊的线性表。“先来的数据先处理”是一种很常见的思路，所以队列的应用范围非常广泛，实际上我们能够直接接触到的队列的应用是要高于栈的应用的，比如各种并发队列，消息队列。另外在广度优先搜索算法中，通常就会从搜索候补中选择最早的数据作为下一个顶点。此时，在候补顶点的管理上就可以使用队列。

另外，关于Java 栈的数据结构，可以看这篇文章：数据结构—栈(Stack)的原理以及Java实现以及后缀表达式的运算。

相关文章：

  1. 《大话数据结构》
  2. 《算法图解》
  3. 《我的第一本算法书》

如果有什么不懂或者需要交流，可以留言。另外希望点赞、收藏、关注，我将不间断更新各种Java学习博客！

avatar
文章
阅读
粉丝
相关推荐
一文弄懂mybatis中SqlSession、SqlSessionTemplate、SessionFactory和SqlSessionFactoryBean关系
1.2k阅读
 · 
4点赞
手把手教你java线程池动态配置调整
4.3k阅读
 · 
15点赞
Java并发系列：线程池ThreadPoolExecutor参数自定义
948阅读
 · 
0点赞
(Inheritable)ThreadLocal源码分析以及内存泄漏等问题
288阅读
 · 
1点赞
Spring5 全家桶 | 45 - Spring Boot 2.x 启动流程解析
1.3k阅读
 · 
41点赞
Java项目的程序里为什么老用注解？注解有哪些作用
4.5k阅读
 · 
34点赞
一天一种JAVA设计模式之四：建造者模式
265阅读
 · 
1点赞
四、Mybatis 执行流程全解析
2.2k阅读
 · 
6点赞
线程池系列三：动态修改线程池队列大小
1.3k阅读
 · 
3点赞

友情链接：