数组队列

最新推荐文章于 2023-05-12 10:28:50 发布
最新推荐文章于 2023-05-12 10:28:50 发布
阅读量497 收藏
点赞数
分类专栏： Java 数据结构 文章标签： 自定义数组队列 队列相关概念 队列原理 队列实现 数组队列的复杂度分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/longgeqiaojie304/article/details/87871186
版权

数组队列

1、队列相关概念

  • 队列是一种线性结构
  • 相比数组，队列的操作是数组的子集
  • 只能从一端（队尾）添加元素，只能从另一端（队首）取出元素

 

2、队列原理

       队列是一种先进先出的数据结构（先到先得）

       Fist In First Out（FIFO）

  

       队首取出元素，队尾添加元素。

 

3、队列实现

（1）队列需要实现的方法

（2）底层使用数组实现队列

 

（3）编码实现队列

     Queue接口定义：

public interface Queue<E> {

    // 入队

    void enqueue(E e);



    // 出队

    E dequeue();



    // 获取队首元素

    E getFront();



    // 获取队列大小

    int getSize();



    // 判断队列是否为空

    boolean isEmpty();



}

动态数组Array定义：

public class Array<E> {

    // 定义数组变量，data.length表示数组容量capacity

    private E[] data;

    // 定义数组中存放数据大小

    private int size;



    // 有参构造方法，传入数组的容量capacity构造动态数组

    public Array(int capacity) {

        data = (E[]) new Object[capacity];

        size = 0;

    }



    // 无参构造方法，默认初始容量为capacity=10

    public Array() {

        this(10);

    }



    // 获取数组中元素个数

    public int getSize() {

        return size;

    }



    // 获取数组的容量

    public int getCapacity() {

        return data.length;

    }



    // 判断数组是否为空

    public boolean isEmpty() {

        return size == 0;

    }



/*    // 在数组末尾添加元素

    public void addLast(E e) {

        if (size == data.length)

            throw new IllegalArgumentException("AddLast failed.Array is full.");

        data[size] = e;

        size++;

    }*/



    // 在数组末尾添加元素（复用add方法）

    public void addLast(E e) {

        add(size, e);

    }



    // 在数组头部添加元素（复用add方法）

    public void addFirst(E e) {

        add(0, e);

    }



    // 数组指定位置添加元素

    public void add(int index, E e) {

//        if (size == data.length)

//            throw new IllegalArgumentException("Add failed.Array is full.");

        if (index < 0 || index > size)

            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");

        if (size == data.length)

            resize(2 * data.length);

        for (int i = size - 1; i >= index; i--)

            data[i + 1] = data[i];

        data[index] = e;

        size++;

    }



    // 获取index索引位置的元素

    public E get(int index) {

        if (index < 0 && index >= size) {

            throw new IllegalArgumentException("Get failed.Index is illegal.");

        }

        return data[index];

    }



    // 获取第一个元素

    public E getFirst() {

        return this.get(0);

    }



    // 获取最后一个元素

    public E getLast() {

        return this.get(size - 1);

    }



    // 修改index索引位置的元素

    public void set(int index, E e) {

        if (index < 0 || index >= size) {

            throw new IllegalArgumentException("Set failed.Index is illegal.");

        }

        data[index] = e;

    }



    // 查找数组中是否存在元素e

    public boolean contains(E e) {

        for (int i = 0; i < size; i++) {

            if (data[i] == e) {

                return true;

            }

        }

        return false;

    }



    // 查找数组中元素e所在的索引，如果不存在元素e，则返回-1

    public int find(E e) {

        for (int i = 0; i < size; i++) {

            if (data[i] == e) {

                return i;

            }

        }

        return -1;

    }



    // 从数组中删除index位置的元素，返回删除的元素

    public E remove(int index) {

        if (index < 0 || index >= size) {

            throw new IllegalArgumentException("Remove failed.Index is illegal");

        }

        E ret = data[index];

        for (int i = index + 1; i < size; i++) {

            data[i - 1] = data[i];

        }

        size--;

        // loitering objects != memory leak 手动释放内存空间

        data[size] = null;

//        if(size == data.length / 2) {

//            resize(data.length / 2);

//        }

        // resize缩容优化方案（Lazy）

        if (size == data.length / 4 && data.length / 2 != 0) {

            resize(data.length / 2);

        }

        return ret;

    }



    // 删除数组第一个元素，返回删除的元素

    public E removeFirst() {

        return remove(0);

    }



    // 删除数组最后一个元素

    public E removeLast() {

        return remove(size - 1);

    }



    // 删除数组中指定元素e

    public void removeElement(E e) {

        int index = find(e);

        if (index != -1) {

            remove(index);

        }

    }



    // 数组扩容

    private void resize(int newCapacity) {

        E[] newData = (E[]) new Object[newCapacity];

        for (int i = 0; i < size; i++) {

            newData[i] = data[i];

        }

        data = newData;

    }



    // 重写父类toString()方法

    @Override

    public String toString() {

        StringBuilder sb = new StringBuilder();

        sb.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));

        sb.append('[');

        for (int i = 0; i < size; i++) {

            sb.append(data[i]);

            if (i != size - 1) {

                sb.append(',');

            }

        }

        sb.append(']');

        return sb.toString();

    }

}

基于动态数组Array实现的ArrayQueue：

public class ArrayQueue<E> implements Queue {



    private Array<E> array;



    public ArrayQueue() {

        array = new Array<>();

    }



    public ArrayQueue(int capacity) {

        array = new Array<>(capacity);

    }



    @Override

    public void enqueue(Object o) {

        array.addLast((E) o);

    }



    @Override

    public E dequeue() {

        return array.removeFirst();

    }



    @Override

    public Object getFront() {

        return array.getFirst();

    }



    @Override

    public int getSize() {

        return array.getSize();

    }



    @Override

    public boolean isEmpty() {

        return array.isEmpty();

    }



    @Override

    public String toString() {

        StringBuilder sb = new StringBuilder();

        sb.append("Queue:");

        sb.append("front [");

        for (int i = 0; i < array.getSize(); i++) {

            sb.append(array.get(i));



            if (i != array.getSize() - 1) {

                sb.append(", ");

            } else {

                sb.append("] tail");

            }

        }

        return sb.toString();

    }

}

测试队列ArrayQueue：

public class Main {



    public static void main(String[] args) {

        ArrayQueue<Integer> arrayQueue = new ArrayQueue<>(10);

        System.out.println("入队操作开始：");

        for (int i = 0; i < 10; i++) {

            arrayQueue.enqueue(i);

            // 入队操作

            System.out.println(arrayQueue);

        }

        // 打印入队10个元素之后的队列

        System.out.println(arrayQueue);



        // 出队操作

        arrayQueue.dequeue();

        System.out.println("出队操作开始：");

        System.out.println(arrayQueue);



    }

}

测试结果如下：

入队操作开始：

Queue:front [0] tail

Queue:front [0, 1] tail

Queue:front [0, 1, 2] tail

Queue:front [0, 1, 2, 3] tail

Queue:front [0, 1, 2, 3, 4] tail

Queue:front [0, 1, 2, 3, 4, 5] tail

Queue:front [0, 1, 2, 3, 4, 5, 6] tail

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

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

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

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

出队操作开始：

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

 

Process finished with exit code 0

 

4、数组队列的复杂度分析

E dequeue() 时间复杂度为O(n)，因为出队底层操作是动态数组，出队操作实际上就是删除数组第一个元素，然后数组后面的元素全部往前移动一个位置，所以dequeue()时间复杂度为O(n)。

 

如果感兴趣的童鞋，可以观看我下一篇博客：敬请期待

Drogon Brother
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数据结构之队列（数组上）
qq_42114509的博客
06-07 385
我们去银行办理业务时，经常会用到排号机，每去一个人取一个号码，银行柜台办理一个业务叫一个号,其中我们排队的过程就是用到了队列。
数组实现队列
09-13
由数组实现队列，包括队列的创建、入队和出队。通过打印显示出队的结果。正在学习数据结构的童鞋可以参考。
数据结构之动态数组队列Queue
qq_44426152的博客
12-13 224
一、队列的顺序存储结构 1）队列的定义 队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表 队列是一种先进先出（First In Last Out）的线性表，简称FIFO 允许插入的一端称为队尾，允许删除的一端称为队头 2）队列接口Queue的定义 public interface Queue<E> extends Iterable<E>{ //获...
数据结构_栈、队列和数组
light_2025的博客
05-12 900
根据题目中 A[0][0] 和 A[3][3] 的存储地址可以知道 A[3][3] 是220-100+1=121个元素，假设每一行存储 n 个元素，A[3][3] 也就是第121个元素：121=3*n+4 (加4是因为存储在数组中是从下角标0开始的)，解得 n=39，也就是说一行存放 39 个元素，A[5][5] 存储的地址就是 39*5+6-1=300。依次进栈，那么进栈顺序是确定的，而且要求计算以元素d开头的序列个数，那么出栈的首个元素一定是d，也就是说a b c d 进栈之后，d会进行出栈操作。
队列数组
wangjiyuan123的博客
10-23 592
问题描述：创建10个队列，分别编号为0-9（处理为队列数组，编号即下标）。 输入若干个正整数，以数字0作为结束。设输入的值为x，其个位数字的大小为i，则将x插入到编号为i的队列中。 最后输出所有的非空队列。 要求将队列处理成链式队列，使用链式队列算法库中定义的数据类型及算法， 程序中只包括一个函数（main函数），入队和出队等操作直
ArrayQueue(队列)
ding7530的博客
08-18 189
　　code1: #include <stdio.h> #include <conio.h> #include <stdlib.h> #define MAXSIZE 65533 #define bool int #define true 1 #define false 0 typedef int KeyType; ...
C++数据结构之数组队列模版实现
09-20
队列是一种先入先出的数据结构（FIFO），只允许在前端(front)删除，在后端(rear)插入。容量为capacity大小的内存，只能存capacity-1的元素，其中rear的位置始终为空。 本文实现的队列，功能如下： 1 获取元素内容 ...
数组队列实现
07-23
学习数据结构过程中，亲自在VC++上编译通过的使用数组实现队列的源代码，与大家共享。
Java数组队列概念与用法实例分析
08-19
主要介绍了Java数组队列概念与用法,结合实例形式分析了Java数组队列相关概念、原理、用法及操作注意事项,需要的朋友可以参考下
数组队列学习代码：队列和环形队列
04-18
普通队列 1)将尾指针往后移：rear+1,当front==rear【空】 2)若尾指针rear小于队列的最大下标maxSize-1,则将数据存入rear所指的数中组元素中，否则无法存入数据。rear==maxSize-1[队列满] 环形队列 1)front变量的...
arrayQueue.zip
12-08
队列的数组形式实现，见文章：https://blog.csdn.net/qq_41453285/article/details/103444692
PHP使用数组实现队列
10-28
PHP的数组处理函数还可以将数组实现队列，堆栈是“先进后出”。在堆栈中，最后压入的数据（进栈），将会被最先弹出（出栈）。而队列是先进先出，就如同银行的排号机
jdk8源码之Queue-ArrayQueue
灵小帝的博客
03-02 3092
列队是一种先进先出（FIFO）的数据结构。删除操作只能在表的头部，插入操作只能在表的尾部。 本章节先学习一下基于数组实现的队列ArrayQueue
ArrayBlockingQueue详解
qq_23359777的博客
04-12 2万+
1.介绍 ArrayBlockingQueue是一个阻塞式的队列，继承自AbstractBlockingQueue,间接的实现了Queue接口和Collection接口。底层以数组的形式保存数据(实际上可看作一个循环数组)。常用的操作包括 add ,offer,put，remove,poll,take,peek。 前三者add offer put 是插入的操作。后面四个方法是取出的操作。他们之
队列——数组实现
yangwenxiao123456的博客
08-14 1万+
队列是一种先进先出的思想。（First In First Out) 关于队列的定义就不叙述了，百度比我讲的详尽的多，在这里说一下用数组实现队列的思想，并附上代码。 我们身边的与队列相关实例很多，火车站排队买票或是买饭是排队，都是队列。因此我们很容易想到，队列是有一个头一个尾的，新来的总是在尾，最先来的总是最先买票或是吃饭，当然，像插队一类的我们不做考虑，相信我们都不会喜欢这些的。 队列的成员...
Queue（队列）添加及删除元素的方法
q875401793的博客
09-16 9413
Queue 中 add() 和 offer()都是用来向队列添加一个元素。 在容量已满的情况下，add() 方法会抛出IllegalStateException异常，offer() 方法只会返回 false 。 Queue 中 remove() 和 poll()都是用来从队列头部删除一个元素。 在队列元素为空的情况下，remove() 方法会抛出NoSuchElementException异常，poll() 方法只会返回 null 。 ...
队列queue的详细讲解
qq_15543985的博客
04-05 849
一、Java  Queue基础Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构offer，add区别：一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，多出的项就会被拒绝。这时新的 offer 方法就可以起作用了。它不是对调用 add() 方法抛出一个 unchecked 异常，而只是得到由 offer() 返回的 false。poll，remove区别：remove...
JavaScript学习笔记：数组(三)【转】
weixin_30561177的博客
05-05 618
JavaScript是一种弱类型语言，不像其它程序语言需要严格定义数据类型。在JavaScript中数组可以任意修改变动，这样也就出现了一个问题，如果边遍历数组边操作数组（比如删除当前项，则所有之后的数组元素下标都将向前移动）是一件很危险的事情。 JavaScript的数组是一个拥有堆栈和队列自身优点的global对象。也就是说JavaScript数组可以表现的像栈(LIFO)和队列(FIFO)...
JVM常用基础参数-元空间MetaspaceSize讲解
热门推荐
泷泷养的乔小胖
06-28 2万+
JVM常用基础参数-元空间MetaspaceSize讲解 大厂面试题： 1、JVM垃圾回收时候如何确定垃圾？是否知道什么是GC Roots 2、你说你做过JVM参数调优和参数配置，请问如何盘点查看JVM系统默认值 3、你平时工作中用过的JVM常用基本配置参数有哪些？ 4、强引用、软引用、弱引用、虚引用费别是什么？ 5、请你谈谈对OOM的认识 6、GC垃圾回收算法与垃圾收集器的关系？分...
使用python的greenlet实现，系统中有2个协程：生产者、消费者 生产者生产'a'、'b'、'c'、‘d'、'e'、'f'、'g'、'h'八个字符 消费者获得生产者传递的数据，并将其打印到屏幕上 此题不使用数组队列，使用协程切换实现
最新发布
06-06
好的，这是一个经典的生产者消费者问题，可以使用 Python 的 `greenlet` 库来实现。以下是代码实现： ```python from greenlet import greenlet def producer(consumer): chars = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] for char in chars: while not consumer.switch(char): pass def consumer(): while True: char = producer_coroutine.switch() print(char) producer_coroutine = greenlet(producer) consumer_coroutine = greenlet(consumer) producer_coroutine.switch(consumer_coroutine) ``` 在这个例子中，我们同样定义了两个函数 `producer` 和 `consumer`，分别用来生产和消费数据。`producer` 函数往队列中不断添加字符，并通过 `switch` 方法切换到 `consumer` 函数执行。如果 `consumer` 函数返回了 False，则说明队列已经满了，需要等待 `consumer` 函数消费掉一些字符后才能继续添加字符。`consumer` 函数从队列中获取字符并打印到屏幕上，然后通过 `switch` 方法切换回 `producer` 函数执行。注意，我们使用了一个无限循环来不断获取队列中的字符，直到队列被清空。 接着，在主程序中，我们同样创建了两个 `greenlet` 对象作为协程，一个是生产者协程 `producer_coroutine`，另一个是消费者协程 `consumer_coroutine`。然后，我们通过调用 `producer_coroutine.switch(consumer_coroutine)` 方法，将协程切换到 `consumer` 函数执行。这样，我们就完成了生产者消费者的协程实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值