08队列

最新推荐文章于 2022-01-05 01:00:45 发布
最新推荐文章于 2022-01-05 01:00:45 发布
阅读量163 收藏
点赞数
分类专栏： 数据结构与算法 数据结构学习笔记 文章标签： 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/firemaple_li/article/details/86104955
版权

文章目录

1.概念

先进者先出，是一种操作受限的线性结构，只有两种操作：入队enquque()和 出队dequeue().

2.分类

基于数组实现的叫顺序队列，基于链表实现的叫链式队列.

2.1顺序队列

2.1.1 不可变大小的队列

package com.desmond.codebase.algorithm.queue;

/**
 * 固定大小的顺序队列
 * @author presleyli
 * @date 2019/1/7 12:51 PM
 */
public class FixedArrayQueue {
    private String[] arr;

    private int n;
    private int head = 0;
    private int tail = 0;

    public FixedArrayQueue(int n) {
        this.n = n;
        this.arr = new String[n];
    }

    /**
     * O(1)
     * @param ele
     * @return
     */
    public boolean enQueue(String ele) {
        if(tail == n) { // 1
            return false;
        }

        arr[tail++] = ele; // 1

        return true;
    }

    /**
     * O(1)
     * @return
     */
    public String deQueue() {
        if(head == tail) { // 1
            return "";
        }

        String ele = arr[head++]; // 1

        return ele;
    }

    public static void main(String[] args) {
        FixedArrayQueue arrayQueue = new FixedArrayQueue(3);

        System.out.println(arrayQueue.enQueue("1"));
        System.out.println(arrayQueue.enQueue("2"));
        System.out.println(arrayQueue.enQueue("3"));
        System.out.println(arrayQueue.enQueue("4"));

        System.out.println(arrayQueue.enQueue("5"));

        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
    }
}

2.1.2 可变大小的顺序队列

package com.desmond.codebase.algorithm.queue;

/**
 * 可扩容的顺序队列-无限扩容.
 * @author presleyli
 * @date 2019/1/7 12:51 PM
 */
public class ChangeableArrayQueue {
    private String[] arr;

    private int n;
    private int head = 0;
    private int tail = 0;

    public ChangeableArrayQueue(int n) {
        this.n = n;
        this.arr = new String[n];
    }

    /**
     * 最好：O(1)
     * 最坏: O(n)
     * 平均(均摊): O(1)
     * @param ele
     * @return
     */
    public boolean enQueue(String ele) {
        if(tail == n) { // 1
            ensureCapable();
        }

        arr[tail++] = ele; // 1

        return true;
    }

    /**
     * 扩容.
     * O(n)
     */
    public void ensureCapable() {
        int newSize = n * 2;

        String[] newArr = new String[newSize];
        System.arraycopy(arr, 0, newArr, 0, n);

        n = newSize;
        arr = newArr;
    }

    /**
     * O(1)
     * @return
     */
    public String deQueue() {
        if(head == tail) { // 1
            return "";
        }

        String ele = arr[head++]; // 1

        return ele;
    }

    public static void main(String[] args) {
        ChangeableArrayQueue arrayQueue = new ChangeableArrayQueue(2);

        System.out.println(arrayQueue.enQueue("1"));
        System.out.println(arrayQueue.enQueue("2"));
        System.out.println(arrayQueue.enQueue("3"));
        System.out.println(arrayQueue.enQueue("4"));
        System.out.println(arrayQueue.enQueue("5"));
        System.out.println(arrayQueue.enQueue("6"));

        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
    }
}

2.1.3 利用固定长度，可变的顺序队列

package com.desmond.codebase.algorithm.queue;

/**
 * 可变顺序队列-利用固定arr本身剩余空间.
 * @author presleyli
 * @date 2019/1/7 12:51 PM
 */
public class ChangeableArrayQueueV2 {
    private String[] arr;

    private int n;
    private int head = 0;
    private int tail = 0;

    public ChangeableArrayQueueV2(int n) {
        this.n = n;
        this.arr = new String[n];
    }

    /**
     * 最好：O(1)
     * 最坏: O(n)
     * 平均(均摊): O(1)
     * @param ele
     * @return
     */
    public boolean enQueue(String ele) {
        if(tail == n) { // 1
            // 如果已经是第一个了，表明无元素出队，
            // 队列满了
            if(head == 0) {
                return false;
            }

            // 不扩充arr容量，搬迁.
            /*
                最好： head = tail - 1, 只搬移一个元素：O(1)
                最坏： head = 1, 搬移 n-1个元素：O(n)
                平均： 1*(1/(n-1)) + 2*(1/(n-1))
                 + 3*(1/(n-1)) + (n-1)*(1/(n-1)) = n²/(2n-2) -> O(n)
             */
            for(int i= head; i < tail; i++) {
                arr[i-head] = arr[i];
            }

            tail = tail - head;
            head = 0;
        }

        arr[tail++] = ele; // 1

        return true;
    }

    /**
     * O(1)
     * @return
     */
    public String deQueue() {
        if(head == tail) { // 1
            return "";
        }

        String ele = arr[head++]; // 1

        return ele;
    }

    public static void main(String[] args) {
        ChangeableArrayQueueV2 arrayQueue = new ChangeableArrayQueueV2(2);

        System.out.println(arrayQueue.enQueue("1"));
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.enQueue("2"));
        System.out.println(arrayQueue.enQueue("3"));
        System.out.println(arrayQueue.enQueue("4"));
        System.out.println(arrayQueue.enQueue("5"));
        System.out.println(arrayQueue.enQueue("6"));


        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
    }
}

2.2链式队列

package com.desmond.codebase.algorithm.queue;

/**
 * 链式队列.
 * @author presleyli
 * @date 2019/1/7 10:33 PM
 */
public class LinkedListQueue {

    private Node head;
    private Node tail;

    /**
     * O(1).
     * @param data
     * @return
     */
    public boolean enQueue(String data) {
        if(tail == null) {
            Node node = new Node(data, null);

            tail = node; // 只是把node的首地址给tail
            head = node; // 只是把node的首地址给tail
        } else {
            Node node = new Node(data, null);
            tail.next = node; // 利用tail首地址(指针)找到tail所指的实际堆里的对象，把其对象的next指针指向新的结点node.

            tail = node; // 只是把node的首地址给tail
        }

        printAll();

        return true;
    }

    /**
     * O(1).
     * @return
     */
    public String deQueue() {
        if(head == null) {
            return null;
        }

        String data = head.data;

        if(head.next == null) {
            head = null;
            tail = null;
        } else {
            Node current = head;

            head = head.next;

            current = null;
        }

        printAll();

        return data;
    }

    public void printAll() {
        StringBuilder sb = new StringBuilder();
        for(Node node = head; node != null || node != tail; node = node.next) {
            if(node == null) {
                break;
            }

            sb.append(node.data).append(">>>>");
        }

        System.out.println(sb);
    }

    public static void main(String[] args) {
        LinkedListQueue queue = new LinkedListQueue();

        System.out.println(queue.enQueue("1"));
        System.out.println(queue.enQueue("2"));
        System.out.println(queue.enQueue("3"));
        System.out.println(queue.enQueue("4"));
        System.out.println(queue.enQueue("5"));

        System.out.println(queue.deQueue());
        System.out.println(queue.deQueue());
        System.out.println(queue.deQueue());
        System.out.println(queue.deQueue());
        System.out.println(queue.deQueue());
        System.out.println(queue.deQueue());
        System.out.println(queue.deQueue());
        System.out.println(queue.deQueue());
    }

    private static class Node {
        private String data;
        private Node next;

        public Node(String data, Node next) {
            this.data = data;
            this.next = next;
        }
    }
}

2.3循环队列

2.3.1 概念

循环队列：

循环队列，顾名思义，它长得像一个环。原本数组是有头有尾的，是一条直线。现在我们把首尾相连，扳成了一个环

最重要的是 队空和队满判定：

队列满条件：head = (tail+1)%n
队列空条件：head=tail

2.3.2 示意图

在这里插入图片描述

2.3.3 代码

package com.desmond.codebase.algorithm.queue;

/**
 * 循环队列：
 * 判断 队列满条件：head = (tail+1)%n <br/>
 * 队列空条件：head=tail <br/>
 * 浪费了一个空间.
 * @author presleyli
 * @date 2019/1/8 7:55 PM
 */
public class CircularQueue {
    private int head;
    private int tail;
    private int n;

    private String[] arr;

    public CircularQueue(int n) {
        this.n = n;
        arr = new String[n];
    }

    /**
     * O(1)
     * @param data
     * @return
     */
    public boolean enQueue(String data) {
        int tmp = (tail + 1)%n; // head = (tail+1)%n
        if(head == tmp) { // 队满条件:  head = (tail+1)%n
            return false;
        }

        arr[tail++] = data;

        tail = tail >= n ? 0 : tail;

        printAll();

        return true;
    }

    /**
     * O(1)
     * @return
     */
    public String deQueue() {
        // 队空 条件： head=tail
        if(head == tail) {
            return null;
        }

        String data = arr[head];

//        head = head + 1;
//        head = head >= n ? 0 : head;
        head = (head + 1) % n;

        printAll();

        return data;
    }

    public void printAll() {
        StringBuilder sb = new StringBuilder();

        if(head < tail) {
            for(int i=head;i<tail;i++) {
                sb.append(arr[i]).append(">>>");
            }
        } else if(head > tail) {
            for(int i=head; i<n; i++) {
                sb.append(arr[i]).append(">>>");
            }

            for(int i=0; i<tail; i++) {
                sb.append(arr[i]).append(">>>");
            }
        }

        System.out.println(sb);
    }

    public static void main(String[] args) {
        CircularQueue queue = new CircularQueue(4);

        System.out.println(queue.enQueue("1"));
        System.out.println(queue.enQueue("2"));
        System.out.println(queue.enQueue("3"));
        System.out.println(queue.deQueue());
        System.out.println(queue.deQueue());
        System.out.println(queue.deQueue());

        System.out.println(queue.enQueue("5"));
        System.out.println(queue.enQueue("6"));
        System.out.println(queue.enQueue("7"));
        System.out.println(queue.enQueue("8"));
        System.out.println(queue.enQueue("9"));


        System.out.println(queue.deQueue());

    }
}

3.应用

3.1阻塞队列

3.2并发队列

3.3资源池

​ 线程池没有空闲线程时，新的任务请求线程资源时，线程池该如何处理？各种处理策略又是如何实现的呢？ 我们一般有两种处理策略。

  • 第一种是非阻塞的处理方式，直接拒绝任务请求；
  • 另一种是阻塞的处理方式，将请求排队，等到有空闲线程时，取出排队的请求继续处理。

​ 那如何存储排队的请求呢？ 我们希望公平地处理每个排队的请求，先进者先服务，所以队列这种数据结构很适合来存储排队请求。我们前面说过，队列有基于链表和基于数组这两种实现方式。这两种实现方式对于排队请求又有什么区别呢？ 基于链表的实现方式，可以实现一个支持无限排队的无界队列（unbounded queue），但是可能会导致过多的请求排队等待，请求处理的响应时间过长。所以，针对响应时间比较敏感的系统，基于链表实现的无限排队的线程池是不合适的。

​ 而基于数组实现的有界队列（bounded queue），队列的大小有限，所以线程池中排队的请求超过队列大小时，接下来的请求就会被拒绝，这种方式对响应时间敏感的系统来说，就相对更加合理。不过，设置一个合理的队列大小，也是非常有讲究的。队列太大导致等待的请求太多，队列太小会导致无法充分利用系统资源、发挥最大性能。

​ 除了前面讲到队列应用在线程池请求排队的场景之外，队列可以应用在任何有限资源池中，用于排队请求，比如数据库连接池等。实际上，对于大部分资源有限的场景，当没有空闲资源时，基本上都可以通过“队列”这种数据结构来实现请求排队

desmond_assis
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DSW08队列答案.html
04-24
DSW08队列答案.html
19.线程池中的队列
郑学炜的技术博客
05-18 9160
runnableTaskQueue（任务队列）：用于保存等待执行的任务的阻塞队列。 可以选择以下几个阻塞队列：BlockingQueue的几个注意点【1】BlockingQueue 可以是限定容量的。它在任意给定时间都可以有一个remainingCapacity，超出此容量，便无法无阻塞地put 附加元素。没有任何内部容量约束的BlockingQueue 总是报告Integer.MAX_VALUE...
线程池+内存队列处理任务
meser88的博客
11-24 375
1,初始化线程池 @Component public class InitListener { @PostConstruct public void init() { // 初始化工作线程池和内存队列 RequestProcessorThreadPool.init(); } } 2.请求处理线程池 package org.concu.lis; import java.util.concurrent.ArrayBlockingQueue;
线程池中的存储队列（阻塞队列）
calm_encode的博客
09-05 1328
一 概述 线程池中超过核心线程数corePoolsize的线程会放入线程池中存储队列中，存储队列是一种阻塞式队列。 二 阻塞队列 阻塞队列是支持阻塞插入和阻塞移除方法的队列。阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取元素的线程。阻塞队列就是生产者用来存放元素、消费者用来获取元素的容器。 支持阻塞的插入方法（put(E e)）：当队列满时，队列会阻塞插入元素的线程，直至队列不满。 支持阻塞的移除方法（take()）：当队列空时，队列会阻塞移除元素的线程，直
阻塞队列&线程池
Android小白
05-15 1124
前言 阻塞队列是线程池的基础。两者都是面试热点，尤其是线程池。所以我特地花时间学习了一下这方面的知识，并做记录。 一.阻塞队列 这个其实用的非常多。安卓里面 Handler机制的MessageQueue，我认为就是一个阻塞队列。 ...
java线程池ThreadPoolExecutor类使用详解
dianyuzhi7625的博客
10-04 1196
在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由于jdk中Executor框架虽然提供了如newFixedThrea...
[原创] jQuery源码分析-08队列 Queue
03-27
NULL 博文链接：https://nuysoft.iteye.com/blog/1189156
第5章 单调队列优化动态规划（2021.08.19）.pdf
08-19
第5章 单调队列优化动态规划（2021.08.19）.pdf
算法面试通关40讲完整课件 08-10 堆栈、队列
最新发布
07-06
算法面试通关40讲完整课件 08-10 堆栈、队列 算法面试通关40讲完整课件 08-10 堆栈、队列 算法面试通关40讲完整课件 08-10 堆栈、队列 算法面试通关40讲完整课件 08-10 堆栈、队列 算法面试通关40讲完整课件 08-10 ...
第5章 单调队列优化动态规划（2021.08.23）.pdf
08-23
第5章 单调队列优化动态规划（2021.08.23）.pdf
工作队列池，线程池
06-01
NULL 博文链接：https://zlr.iteye.com/blog/1161339
队列：队列在线程池等有限资源池中的应用
every__day的博客
11-21 539
电脑的CPU资源是有限的，任务的处理速度与线程数量之间并不是正相关。当线程数量过多，CPU要频繁的在不同线程切换，反而会引起处理性能的下降。线程池中最大的线程数，是考虑多种因素来事先设定的，比如硬件的条件，业务的类型等等。 ...
基于队列queue实现的线程池
09-08 151
本文通过文章同步功能推送至博客园，显示排版可能会有所错误，请见谅! 写在前文：在Python中给多进程提供了进程池类，对于线程，Python2并没有直接提供线程池类（Python3中提供了线程池功能），而线程池在并行中应用较广泛，因此实现一个进程池的功能十分必要。本文基于队列（queue）功能来实现线程池功能。 在Python3标准库中提供了线程池、进程池功能，推荐使用标准库。 ...
线程-线程池-任务队列
weixin_41942838的博客
01-05 198
线程池为什么可以复用 把线程池讲的这么清楚 优雅的使用线程池以及源码剖析
Java多线程（四）———线程池任务队列ArrayBlockingQueue
余韵啊
06-24 1015
上面的一篇文章，我们介绍了线程池的拒接策列，这篇文章开始我们介绍线程池任务队列中的等待队列—— ArraBlockingQueue。 先看看ArrayBlockingQueue的继承和实现的关系的图。 ArrayBlockQueue是一个有界的队列，这个队列排列元素FIFO(先进先出)，其中队列元素是用一个数组来保存的，创建时指定队列的大小，创建后，容量无法改变。 从上面的图可以看到，ArrayBlockQueue是继承了AbstractQueue类，和实现了BlockingQueue接口。 看一下Abs
线程池中的任务队列
Charzzzzlie的博客
10-01 1769
workQueue 上篇讲到Java核心的几个线程池都是对ThreadPoolExecutor类的封装，该类的构造方法中有个参数为workQueue。 该参数是指被提交但未执行的任务队列，它是一个BlockingQueue接口的对象，用于存放Runable对象。根据功能分类，在ThreadPoolExecutor类的构造函数中可使用以下几种BlockingQueue接口。 直接提交的队列：该功能有SynchronousQueue对象提供。使用该对象，提交的任务不会被真实的保存，而总是将新任务提交到线程执行
线程池作用、用法以及原理
sekever的博客
03-16 7219
线程池作用用法建议设定大小快捷构造线程池submit与executeshutdown与shutdownNow代码底层原理继承关系ThreadPoolExecutor类主要参数工作原理饱和策略 作用 降低资源消耗，减少增加与销毁线程的操作 提高响应速度 提高线程的可管理性 用法 使用ThreadPoolExecutor构造线程池，将线程传入 需要设定特殊参数，如核心线程池大小、最大线程池大小、缓冲队列大小等 建议设定大小 1、CPU计算较多的时候，设置为N+1，N为CPU个数 2、IO操作较多时，设置为2*N
JDK1.8源码分析：Executor和ThreadPoolExecutor线程池的设计和源码实现
源码之下，了无秘密
02-16 4845
概述 Executor线程执行器框架是在jDK1.5提供的，设计的主要目的是实现Runnable任务的提交和执行分离：任务提交主要是指在应用代码中实现Runnable接口定义业务相关的一个任务，然后交给一个Thread线程对象来执行；任务的执行是指Thread线程执行该任务。有了Executor线程执行器之后，我们只需要实现Runnalbe接口定义自己的任务即可，不需要显示创建Thread对象来...
写一个迪文屏解析数据的队列
03-31
data2 = b'\x05\x06\x07\x08' # 将数据包保存到队列中 data_queue.append(data1) data_queue.append(data2) # 从队列中取出数据包进行解析 while data_queue: data = data_queue.popleft() # 解析数据包 # ... ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值