队列及其事例

于 2023-02-15 16:26:50 发布
阅读量215 收藏
点赞数
文章标签： 数据结构 leetcode 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46931102/article/details/129045789
版权

队列

今天要给大家带来的是一期关于数据结构上的内容，队列；这里给大家模拟一个现实场景，昨天不是刚刚过2.14嘛，男同胞们会在奶茶店叫奶茶哦，2.14这天恰好人比较多，需要一个一个排队进行等候，在这里结合多线程给大家具体实现一个模型。

首先给大家实现一个循环队列的模型

大家需要具体从队列上了解，请上力扣队列 & 栈图文学 - LeetBook - 力扣（LeetCode）全球极客挚爱的技术成长平台

package Test.Date_23_2_12;

/**
 * @ClassName ArrayQueue
 * @Description TODO
 * @Author Pzy
 * @Date 2023/2/12 11:33
 * @Version 1.0
 **/
public class ArrayQueue {
    private int Front,Rear;//头尾指针
    private int maxSize;//最大容量
    private int QueueArr [];//给定一个存储数组
    private int Size;//容量

    //构造器
    public ArrayQueue(int k)
    {
        //创建存储数组
        this.maxSize = k;//把参数值传给当前对象的最大容量
        QueueArr = new int [maxSize];//创建容量为k的数组
        Front = -1;//初始化循环队列 头尾指针指向-1
        Rear = -1;
        Size = 0;//容量为0
    }

    //入列
    public boolean enQueue(int value){
        /*
        判断队列是否已满
        1、满了返回false
        2、未满
            1.判断队列是否已满，已满则返回false
            2.由于是循环队列头指针head需要知道具体位置(不一定在第一个元素的位置)
            所以需要判断head 是否 == -1 ，等于-1表示在最初的位置上(未改变)
            3.判断尾指针的位置是否在最后的位置(循环队列需要进行头尾指针的判断)
            尾指针在最后这说明，指向了第一个元素之前的位置
        尾指针 Rear+1 容量 Size+1
         */

        if(this.isFull()){
            return false;
        }
        if(this.Front == -1){this.Front = 0;}//说明在原来的位置上
        if(this.Rear == maxSize -1) {this.Rear =0;}//队列快满了
        else this.Rear++;//尾指针+1
        //一般插入情况
            this.Size++;//容量+1
            this.QueueArr[this.Rear] = value;//数据加入到数组当中
            return true;
    }

    //出列
    public boolean deQueue(){
        if(this.isEmpty()) return false;//判断是否为null
        if (this.Front == maxSize -1) this.Front =0;//判断头指针是否在最初的位置上
        else this.Front++;//头指针+1
        this.Size--;//出列容量减少
        return true;
    }

    //获取队首元素

	//判断队列是否为null
    public boolean isFull(){
        return this.Size == 0;
    }
    
    //判断队列是否已满
    public  boolean isEmpty() {
        return this.Size == maxSize;
    }


}

力扣队列代码

/**
 * @ClassName Queue
 * @Description TODO
 * @Author Love yue yue
 * @Date 2023/2/14 10:44
 * @Version 1.0
 **/
public class Queue {
    //队列
    private int [] data;
    private int head;//头指针
    private int tail;//尾指针
    private int size;//数组大小/容量

    //构造器
    public Queue(int k) {
        data = new int [k];//把参数中的值传入到int 数组需要给定的值当中
        head = -1;//头指针初始值
        tail = -1;//尾指针初始值
        size = k;//k值赋值给数组的容量值
    }

    //入列 队列尾部进入
    public boolean enQueue(int value){
        if(isFull() == true){
            return false;//如果数组已满 直接返回false
        }
        if(isEmpty() == true){
            head = 0;//如果数组位空，标记头指针的位置
        }
        tail = (tail+1)%size;
        /**
         *
         */
        data[tail]= value;//入列数据存储到尾指针指向的位置上  尾插法
        return true;
    }

    //出列 队列头部出列
    public boolean deQueue(){
        //判断队列是否位空 为空则返回false
        if(isEmpty() == true){
            return  false;
        }
        //头指针和尾指针的值相同的话，说明队列已经空了
        if(head == tail){
           head = -1;//头指针初始值
           tail = -1;//尾指针初始值
            return true;
        }
        //不满足以上情况说明队列没有满
        head = (head +1)%size;
        return true;

    }

    //从队列中获取第一项的值
    public int Front(){
        //判断是否为空，为空则返回false
        if(isEmpty() == true){
            return -1;//注意此处的返回值时int类型
        }
        //不为空则进行值的获取
        return data[head];
    }

    //从队列中获取最后第一项的值(和Front相似)
    public int Rear(){
        //判断是否为空，为空则返回false
        if(isEmpty() == true){
            return -1;
        }
        return data[tail];
    }


    //判断队列是否已满
    private boolean isFull() {
        //队列已满 ---- >
        return ((tail+1)%size) == head;
        /**
         * 当head == 0 tail = size-1 的时候 或者
         * head = tail +1
         * 这是队列是否已满的情况两情况(其实是一种)
         */
    }

    //判断队列是否已空
    private boolean isEmpty() {
        //队列为空 --->
        return head == -1;
    }

}

具体要实现一下功能（仿力扣写的功能目标）

  • MyCircularQueue(k): 构造器，设置队列长度为 k 。
  • Front: 从队首获取元素。如果队列为空，返回 -1 。
  • Rear: 获取队尾元素。如果队列为空，返回 -1 。
  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
  • isEmpty(): 判断循环队列是否为空。
  • isFull():判断循环队列是否已满。

下面给大家写了一个使用循环队列和多线程的小Dome (生产者和消费者模型 — 不完整)

需求：有A B C 四个线程 采用流水线方式，A 处理完产品交给B，B处理完产品交给C，C处理完产品交给D

D处理完产品，结束任务。

需要处理的任务：

A处理时 num值增加20

​ num =num +20

B处理时当前num值乘10

​ num = num * 10

C处理时当前num值和当前num值相乘

​ num = num * num

/**
 * @ClassName Task
 * @Description TODO
 * @Author Love yue yue
 * @Date 2023/2/13 11:13
 * @Version 1.0
 **/
public class Task {
    int num;
    public  void taskA(){
        num += 20;
    }

    public  void taskB(){
        num *= 10;
    }

    public  void taskC(){
        num *=num;
    }
}

具体代码如下：

package Test.Date_23_2_13.Test02;

import java.util.LinkedList;

/**
 * @ClassName Joker
 * @Description TODO
 * @Author Love yue yue
 * @Date 2023/2/13 11:17
 * @Version 1.0
 **/
public class Joker {


    public static void main(String[] args) throws InterruptedException {
        LinkedList<Task> t1 = new LinkedList<Task>();
        LinkedList<Task> t2 = new LinkedList<Task>();
        LinkedList<Task> t3 = new LinkedList<Task>();
        LinkedList<Task> t4 = new LinkedList<Task>();


//        for (int i = 0; i < 50000; i++) {
        for (int i = 0; i < 500; i++) {
            t1.offer(new Task());
        }

        //启动线程
        Task task = new Task();

        synchronized (task){//在获取同一个对象锁的时候使用notify和wait
			//容量到达目标 启动A线程
            if(t1.size() == 500){
                new ThreadA_(t1,t2).start();
                
                //容量到达目标 结束A线程
                if(t2.size() == 500){
                    System.out.println("The A end");
                    return;
                }

            }
           }
        
        //监听线程
        //控制台打印
        new Thread(){
            //匿名内部类
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
					//获取当前的队列的容量
                    int asize = t1.size();
                    int bsize = t2.size();
                    int csize = t3.size();
                    int dsize = t4.size();
                    System.out.println("队列A："+asize);
                    System.out.println("队列B："+bsize);
                    System.out.println("队列C："+csize);
                    System.out.println("队列D："+dsize);
                    System.out.println();
                    
                    //处理B线程
                    synchronized (task) {
                        if (t2.size() == 500) {
                            new ThreadB_(t2, t3).start();
                            if(t3.size() == 500) {
                                System.out.println("The B end");
                            }
                        }
                    }
                    
                    //处理C线程
                    synchronized (task) {
                        if (t3.size() == 500) {
                            new ThreadC_(t3, t4).start();
                            if(t4.size() == 500) {
                                System.out.println("The C end");
                            }
                        }
                    }
                    //满足结束任务条件 结束任务
                    if(t1.size() == 0 && t2.size() == 0 && t3.size()==0 && t4.size() ==500){
                        return;
                    }
                }

            }
        }.start();
    }
}

//线程A
class ThreadA_ extends Thread{
    LinkedList<Task> t1;
    LinkedList<Task> t2;

    public ThreadA_(LinkedList<Task> t1, LinkedList<Task> t2) {
        this.t1 = t1;
        this.t2 = t2;
    }

    @Override
    public void run() {
//        while(true) {
        while(true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Task task = t1.poll();
            if(t1.size() == 0 && t2.size() == 500){//当线程t1和t2的容量达到相关值停止添加
                //此处处理顺序如果在调用方法之后会出现 取不到数据的 会发生NullPointerException异常
                break;
            }
            task.taskA();//调用taskA方法

            t2.offer(task);//添加

        }

    }
}

class ThreadB_ extends Thread{
    LinkedList<Task> t2;
    LinkedList<Task> t3;

    public ThreadB_(LinkedList<Task> t2, LinkedList<Task> t3) {
        this.t2 = t2;
        this.t3 = t3;
    }

    @Override
    public void run() {
        while(true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Task task = t2.poll();
            if (t2.size()==0 && t3.size() == 500) break;//处理方式和原理和A线程相似
            task.taskB();//调用taskB方法
            t3.offer(task);//添加到t3中
        }

    }


}

class ThreadC_ extends Thread{
LinkedList<Task> t3;
LinkedList<Task> t4;

    public ThreadC_(LinkedList<Task> t3, LinkedList<Task> t4) {
        this.t3 = t3;
        this.t4 = t4;
    }

    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Task task = t3.poll();
            if(t3.size()==0 && t4.size() == 500) return;//处理方式和原理和A线程相似
            task.taskC();//调用taskC方法
            t4.offer(task);//添加到t4中
        }
    }
}

由于本人目前能力有限，发现可能还有更好的方法去处理共享资源，后续会继续跟进的哦，期待大家的关注。

by夏天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构-队列的示例
孤舟残月梦还长存的专栏
09-29 827
一、队列简介 数据结构中的队列是先进先出，如同一根管道一样的数据结构，队列在程序设计中应用比较广泛。比如说处理数据库的并发请求时，要用到队列，虽然有专门的队列处理工具（如：kafka），但是了解队列这样的数据结构还是必要的。还有一种情况就订单的处理，如果不想遗漏的话，还是需要队列这样的数据结构。 二、队列的数据结构示例代码如下： 程序在安卓系统下的 Compiler C语言编译器下编译通过。 三、程序执行后的效果：
队列的应用实例
weixin_43831728的博客
07-14 2239
队列的应用实例
队列的实例
jifengshuai的专栏
08-03 348
 package test;/* * 队列 * */class Queue{ private int maxSize; private int[] array; private int front; private int rear;//队尾 private int nElems;//队头 public Queue(int max) {  maxSize=max;  array=new int[m
队列的例子
qq_45841233的博客
03-17 150
队列
队列一个简单的例子
m0_46297777的博客
03-13 563
题目： 输入一个n*m的矩阵由0和1组成，1能通过，0不能，再输入起点的位置和终点的位置，求起点到终点的最短路径 int put 4 4 1 1 1 0 1 1 0 0 1 1 0 0 1 1 1 1 1 2 4 4 out 5 #include<iostream> #include<queue> using namespace std; struct pace{ i...
循环队列及其操作
10-10
大学数据结构，循环队列及其例子，基础基础基础中的基础
数据结构学习--队列及其应用
06-25
数据结构学习--队列及其应用 队列是一种重要的数据结构，它广泛应用于计算机科学和信息技术领域。队列的应用非常广泛，例如医院排队、银行排队、超market排队等等。 一、队列的定义 队列是一种特殊的线性表，它...
链队列及其操作
10-10
大学生数据结构，基本的链队列及其操作实现，基础基础
队列及其应用
08-01
队列是一种重要的数据结构，它的主要特点是先进先出（FIFO），即最早进入队列的元素也将是最先离开队列的。在实际应用中，队列常被用来模拟现实生活中的一些场景，比如食堂排队、打印机任务调度等，其核心作用是维持...
顺序循环队列及其操作
11-30
任意输入队列长度和队列中的元素值，构造一个顺序循环队列，对其进行清空、插入新元素、返回队头元素以及删除队头元素操作。
C++队列用法实例
12-25
本文实例讲述了C++队列用法。分享给大家供大家参考。具体如下： /* 队列使用时必须包含头文件 #include 有以下几种方法 入队push(),出队pop(), 读取队首元素front(),读取队尾元素back() ， 判断队是否有元素empty() 求队列元素个数size() */ #include #include using namespace std; int main() { queue one; one.push(1); one.push(2); one.push(3); cout<<
数据结构队列例子（病人就诊）
08-27
关于数据结构队列的知识，病人到医院就诊，就诊时间是随机的（2~9分钟），挂号时间间隔随机的。 用随机数模拟到医院就诊，统计病人等待时间
队列原理与实例讲解
一颗西柚的博客
04-15 1208
队列 队列是一个有序列表, 可以用数组或者链表来实现 遵循先入先出的原则,即: 先存入队列的数据, 要先取出, 后存入的数据要后取出. 数组模拟队列 队列本身是有序列表, 若使用数组的结构 来存储队列的数据, 则队列数组的声明如下图: 其中 maxSize是该队列的最大容量 因为队列的输出, 输入分别从前后端来处理,因此需要两个变量front 及rear分别记录队列前后端的下标, front会随着数据输出而改变, 而rear则是随着数据输入而改变 当我们将数组存入队列时称为"addQ
队列实例（全）
ay_一起沉默 的博客
08-17 4464
队列：只允许在前端（队头）进行删除操作，在后端（队尾）进行插入操作，（先进先出）
一个简单的队列小实例
金啊豆嘞的博客
12-01 571
        队列的设计思想是“先进先出”，而且是只允许队尾进队（插入），队首出队，就如同我们去窗口办理业务一样，需要排队，而办完业务之后，就可以离开队列即出队(删除)。         下面是一个最简单的队列实现示例，但是却意味深长的体现了队列设计及实现的基本思想。         C语言实现的代码如下： #include "stdio.h" struct queue{ int...
队列操作案例
YPL_ZML的博客
03-13 293
from multiprocessing import Process from multiprocessing import Queue import time import random #需求： #在父进程当中创建两个子进程，一个往Queue里写数据，一个从Queue里读取数据： #写操作 def write(q): # 由于进程之间的通信只能通过队列来完成, # 所以队列中最后一个元素&quot;E...
简单易懂的队列实例
qq_45773970的博客
03-18 584
队列 定义：队列——先进先出原则，是一种操作受限的线性表，指只允许在表的一端进行插入操作的数据结构，具有“先进先出”的特点。 比如我们去电影院排队买票，第一个进入排队序列的都是第一个买到票离开队列的人，而最后进入排队序列排队的都是最后买到票的。 队列分为： ①、单向队列（Queue）：只能在一端插入数据，另一端删除数据。 ②、双向队列（Deque）：每一端都可以进行插入数据和删除数据操作。 在此我...
数据结构 - 队列的应用示例（附源码 C）
Jen_Hsueh的博客
04-07 285
需求： 实现存储数据时，保证数据容器里一直是最新数据且顺序排列，读取数据时，不影响容器里的数据。
数据结构之队列（案例版）
会飞的冰箱的博客
12-30 1215
队列是一种特殊性的线性结构，它只允许在队列的首部（head）进行删除操作，这个称作”出队”，而在队列的尾部（tail）进行插入工作，叫做”入队”。这就是我们常说的”先进先出“原则。生活中有很多的这样的案例，例如我们排队买火车票，每个排队买票的窗口就是一个队列，人越靠前就越早买到火车票，越早买完就越早从队列出来，后来的在队尾进入。为了让大家更好的理解队列，在这里简单的介绍一个案例（这个案例来自《啊哈！
栈与队列：顺序队列及其实现
理解栈和队列的概念及其操作对于编程至关重要，它们是解决许多算法问题的基础，比如深度优先搜索（DFS）和广度优先搜索（BFS）。在实际编程中，熟练掌握这两种数据结构的实现和使用，能有效提高代码的效率和可读性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值