数据结构之队列详解

最新推荐文章于 2024-08-22 22:49:21 发布
最新推荐文章于 2024-08-22 22:49:21 发布
阅读量336 收藏
点赞数
分类专栏： 数据结构与算法

目录

队列Queue

队列的实现

队列的时间复杂度

循环队列的时间复杂度


队列Queue

 

  • 队列也是一种线性结构
  • 相比数组，队列对应的操作是数组的子集
  • 只能从一端（队尾）添加元素，只能从另一端（队首）取出元素
  • 队列是一种先进先出的数据结构
  • First In First Out（FIFO）

队列的实现


接口Queue：

/**
 * Created by binzhang on 2019/3/17.
 */
public interface Queue<E> {
    int getSize();
    boolean isEmpty();
    void enqueue(E e);
    E dequeue();
    E getFront();
}

实现类ArrayQueue：

/**
 * Created by binzhang on 2019/3/17.
 */
public class ArrayQueue<E> implements Queue<E> {

    private Array<E> array;

    public ArrayQueue(int capacity){
        array = new Array<>(capacity);
    }

    public ArrayQueue(){
        array = new Array<>();
    }

    @Override
    public int getSize() {
        return array.getSize();
    }

    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    public int getCapacity(){
        return array.getCapacity();
    }

    @Override
    public void enqueue(E e) {
        array.addLast(e);
    }

    @Override
    public E dequeue() {
        return array.removeFirst();
    }

    @Override
    public E getFront() {
        return array.getFirst();
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Queue: "));
        res.append('[');
        for (int i = 0 ; i < array.getSize() ; i ++){
            res.append(array.get(i));
            if(i != array.getSize() - 1)
                res.append(", ");
        }
        res.append("] tail");
        return res.toString();
    }

    public static void main(String[] args) {
        ArrayQueue<Integer> queue = new ArrayQueue<>();
        for (int i = 0 ; i < 10 ; i ++){
            queue.enqueue(i);
            System.out.println(queue);
            if (i % 3 == 2){
                queue.dequeue();
                System.out.println(queue);
            }
        }
    }
}

main方法运行结果：

Queue: [0] tail
Queue: [0, 1] tail
Queue: [0, 1, 2] tail
Queue: [1, 2] tail
Queue: [1, 2, 3] tail
Queue: [1, 2, 3, 4] tail
Queue: [1, 2, 3, 4, 5] tail
Queue: [2, 3, 4, 5] tail
Queue: [2, 3, 4, 5, 6] tail
Queue: [2, 3, 4, 5, 6, 7] tail
Queue: [2, 3, 4, 5, 6, 7, 8] tail
Queue: [3, 4, 5, 6, 7, 8] tail
Queue: [3, 4, 5, 6, 7, 8, 9] tail

队列的时间复杂度


ArrayQueue

  • void enqueue(E)    O(1)均摊
  • E dequeue()    O(n)
  • E front()    O(1)
  • int getSize()    O(1)
  • boolean isEmpty()    O(1)

可以看到数组出列的时间复杂度是O(n)的，所有的元素都要向前挪一位，性能相对是比较低的。
循环队列可以解决这个问题。
循环队列加入了front和tail两个属性。
当front==tail时队列为空。
每次入队的时候tail都会向后移动一个单位，当有出队操作时，front也会向后移动一个单位。


当数据插入到位置7后，tail会回到0位置。


那么tail是怎么回到0的呢，当我们插入的元素大于队列长度时采用取余的方式来计算
tail = (i + 1)/capacity
这里就是(7+1)/8（8为数组长度）就回到了我们索引为0的位置

注意我们之前定义了front==tail是队列为空的标志，索引当遇到下图情况即tail+1==front（更准确的说是(tail + 1) % c == front）的时候就表明我们的队列是满的了，可以进行扩容了，也就是说循环队列中总会是浪费一个空间的。
手写一个循环队列：

/**
 * Created by binzhang on 2019/3/17.
 */
public class LoopQueue<E> implements Queue<E> {

    private E[] data;
    private int front, tail;
    private int size;

    public LoopQueue(int capacity){
        // 循环数组是有一个空间浪费的，所以要存储n个要定义空间大小为n+1
        data = (E[])new Object[capacity + 1];
        front = 0;
        tail = 0;
        size = 0;
    }

    public LoopQueue(){
        this(10);
    }

    public int getCapacity(){
        return data.length - 1;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return front == tail;
    }

    @Override
    public void enqueue(E e) {
        if ((tail + 1) % data.length == front)
            resize(getCapacity() * 2);
        data[tail] = e;
        tail = (tail + 1) % data.length;
        size ++;
    }

    private void resize(int newCapacity){
        E[] newData = (E[])new Object[newCapacity + 1];
        for (int i = 0 ; i < size ; i ++)
            newData[i] = data[(i + front) % data.length];
        data = newData;
        front = 0;
        tail = size;
    }

    @Override
    public E dequeue() {
        if (isEmpty())
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        E ret = data[front];
        data[front] = null;
        front = (front + 1) % data.length;
        size --;
        if (size == getCapacity() / 4 && getCapacity() / 2 != 0)
            resize(getCapacity() / 2);
        return ret;
    }

    @Override
    public E getFront() {
        if (isEmpty())
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        return data[front];
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Queue: size = %d, capacity = %d\n", size, getCapacity()));
        res.append("front [");
        for (int i = front ; i != tail ; i = (i + 1) % data.length){
            res.append(data[i]);
            if((i + 1) % data.length != tail)
                res.append(", ");
        }
        res.append("] tail");
        return res.toString();
    }

    public static void main(String[] args) {
        LoopQueue<Integer> loopQueue = new LoopQueue<>();
        for (int i = 0 ; i < 10 ; i ++){
            loopQueue.enqueue(i);
            System.out.println(loopQueue);
            if (i % 3 == 2){
                loopQueue.dequeue();
                System.out.println(loopQueue);
            }
        }

    }
}

输出：

Queue: size = 1, capacity = 10
front [0] tail
Queue: size = 2, capacity = 10
front [0, 1] tail
Queue: size = 3, capacity = 10
front [0, 1, 2] tail
Queue: size = 2, capacity = 5
front [1, 2] tail
Queue: size = 3, capacity = 5
front [1, 2, 3] tail
Queue: size = 4, capacity = 5
front [1, 2, 3, 4] tail
Queue: size = 5, capacity = 5
front [1, 2, 3, 4, 5] tail
Queue: size = 4, capacity = 5
front [2, 3, 4, 5] tail
Queue: size = 5, capacity = 5
front [2, 3, 4, 5, 6] tail
Queue: size = 6, capacity = 10
front [2, 3, 4, 5, 6, 7] tail
Queue: size = 7, capacity = 10
front [2, 3, 4, 5, 6, 7, 8] tail
Queue: size = 6, capacity = 10
front [3, 4, 5, 6, 7, 8] tail
Queue: size = 7, capacity = 10
front [3, 4, 5, 6, 7, 8, 9] tail

循环队列出列的时间复杂度变为O(1)

循环队列的时间复杂度


LoopQueue

  • void enqueue(E)    O(1)均摊
  • E dequeue()    O(1) 均摊
  • E front()    O(1)
  • int getSize()    O(1)
  • boolean isEmpty()    O(1)
LifeBackwards
关注
专栏目录
数据结构（队列）
GinSmile的博客
03-21 4236
建立一个队，1，3，5，7，9入队，再出队列。 链队列的方法和循环队列两种方法。 首先是链队列： #include #include #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 using namespace
C#数据结构之队列(Quene)实例详解
01-20
以上就是C#中队列数据结构的实例详解，包括了队列的基本操作和基于数组的实现方法。理解这些概念和实现对于学习数据结构和算法至关重要，有助于提高编程能力，特别是在解决涉及任务调度、资源管理等问题时。
数据结构之队列【超详解】
m0_52882232的博客
12-21 1209
队列的基本操作
数据结构之队列
最新发布
weixin_74772510的博客
08-22 1727
不会吧不会吧，不会有人不会队列吧......
数据结构之队列的详解
qq_45726327的博客
05-07 1129
队列是一种先入先出(FIFO)的线性表数据结构添加和删除操作只在表的两端进行,一端为队头,另一端为队尾添加操作在队尾进行,称为入队或进队,删除操作在队头进行,称为出队队列是一种先入先出的线性表数据结构可以使用数组或链表实现队列,实现需要包含的方法有入队add、出队remove等队列操作的时间复杂度均为O(1),不受队列大小影响。
（超详细）数据结构——“队列”的深度解析
qq_58761784的博客
07-02 2405
队列与栈都是线性表，它们的结构也非常类似，都是一头进一头出，那么它们有什么区别吗？答案是有的，虽然它们同为线性表，但是栈的出栈入栈方式为后进先出，而队列的出栈入栈方式为先进先出，具体我们在正文讲解。
Python实现的数据结构与算法之队列详解
12-25
本文实例讲述了Python实现的数据结构与算法之队列。分享给大家供大家参考。具体分析如下： 一、概述 队列（Queue）是一种先进先出（FIFO）的线性数据结构，插入操作在队尾（rear）进行，删除操作在队首（front）进行...
Python实现的数据结构与算法之双端队列详解
12-25
本文实例讲述了Python实现的数据结构与算法之双端队列。分享给大家供大家参考。具体分析如下： 一、概述 双端队列（deque，全名double-ended queue）是一种具有队列和栈性质的线性数据结构。双端队列也拥有两端：队...
数据结构栈和队列详解.zip
04-03
栈和队列是两种非常基础且重要的数据结构，它们在计算机科学和软件开发中都有着广泛的应用。下面我将详细解释这两种数据结构。 栈（Stack） 栈是一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。这...
队列数据结构
Jeffxu_lib的博客
09-02 523
一、队列：一种可以实现先进先出的存储结构 1、队列可以分为： 链式队列（动态）：用链表来实现 静态队列（顺序队列）：用数组来实现（静态队列通常都必须是循环队列） 2、链式队列结构如下图： 3、静态队列一般都是循环队列，其目的是为了能重复使用数组的内存，减少内存的浪费。 （1）、如下图所示的循环队列： front = 0 ，rear = 5 ，此时循环队列已满。如下图的队列...
数据结构：队列
weixin_49965654的博客
07-22 1569
好了，队列的数据结构到这里就差不多结束了，总体来说当我们有顺序表和链表的基础之后，队列这个数据结构相对来说还是非常简单的。最后大家一定要多动手操作，一定要自己手敲一遍。求三连！！！！！！
【数据结构】队列详解
fighting小泽的博客
05-19 3244
🌸作者简介：目前正在学习C语言和数据结构。
数据结构：队列的详解
qq_58356691的博客
05-21 340
队列详解
数据结构 —— 队列
林深不见鹿 的博客
10-16 2841
队列 1.队列的介绍 队列是一种先进先出的数据结构，这和栈有所不同，但又更容易理解。类似于食堂排队打饭，车站排队买票。 后来的人排在队伍最后边，先来的人先打饭或者买票走。如图 队列总是从队尾插入元素,而从队首移除元素，满足先进先出的规则。因此需要一个队首指针front指向队首元素的前一个位置，而使用一个队尾指针rear来指向队尾元素。 ，需要一个队首指针front来指向队首元素的前一个位置，而使用一个队尾指针rear来指向队尾元素。和栈类似，当使用数组来实现队列时，队首指针front和队尾指针rear为i
C语言实现数据结构：队列详解
在数据结构课程中，C语言队列是重要的概念，它与栈一起构成了线性表的特殊类型，主要特点是只允许在特定位置进行插入（enqueue）或删除（dequeue）。本章节主要探讨了两种数据结构：栈（Stack）和队列（Queue），...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值