java编程(一)队列

直击高频编程考点:队列知识及经典算法题总结 队列知识及编程练习总结:背景知识 +队列的应用(在Spring中的应用+在其他框架中的应用+在实际开发中的应用)+相关编程练习(用队列实现栈+使用栈实现队列+设计循环队列+滑动窗口最大值 +课程表+队列的最大值+用数组实现一个队列) 阅读详情
  1. 用数组实现一个顺序队列
    package sequentialQueue;
    
    public interface IQueue {
    
        //初始化
        public  void init();
        //入队
        public void enter(Object object) throws Exception;
        //出队
        public Object depaeture() throws Exception;
        //清空队列
        public void clear();
        //获取队列大小
        public int getSize();
        //判断队满
        public boolean isFull();
        //判断队空
        public boolean isEmpty();
    
    }
    package sequentialQueue;
    
    public class Queue implements IQueue{
    
        private static final int MAX_SIZE=100;
        //数组队列
        private Object[] queue;
        //头指针
        private int front;
        //尾指针
        private int rear;
        //初始化大小
        private int length;
    
    
        @Override
        public void init() {
            queue=new Object[this.length+1];
            front=rear=0;
        }
    
        @Override
        public void enter(Object object) throws  Exception{
            if(isFull()){
                throw new Exception("队列已满!");
            }
            queue[rear]=object;
            rear=(rear+1)%queue.length;
        }
    
        @Override
        public Object depaeture() throws Exception{
            if (isEmpty()){
                throw new Exception("队列为空!");
            }
            Object object=queue[front];
            queue[front]=null;
            front=(front+1)%queue.length;
            return object;
        }
    
        @Override
        public void clear() {
            queue=null;
            queue=new Object[this.length];
        }
    
        @Override
        public int getSize() {
            return (rear-front+queue.length)%queue.length;
        }
    
        @Override
        public boolean isFull() {
            return (rear+1)%queue.length == front;
        }
    
        @Override
        public boolean isEmpty() {
            return front==rear;
        }
    
        public Queue(){
            this.length=MAX_SIZE;
            init();
        }
    
        public Queue(int length){
            this.length=length;
            init();
        }
    
        public static void  main(String[] args)throws  Exception{
            Queue queue=new Queue(5);
            char[] data = new char[]{'好','的','长','度','注','意'};
            try {
                for (int i = 0; i <data.length ; i++) {
                    System.out.println("入队数据为:"+data[i]);
                    queue.enter(data[i]);
                }
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("队列大小为:"+queue.getSize());
            try {
                while (!queue.isEmpty()){
                    System.out.println("出队数据为:"+queue.depaeture());
                }
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("队列是否为空:"+queue.isEmpty());
    
        }
    }
    

     

  2. 用链表实现一个链式队列
    package chainQueue;
    
    public interface ICQueue {
        //判空
        public boolean isEmpty();
        //添加元素
        public boolean addQueue(Object object);
        //删除元素
        public boolean deleteQueue();
    }
    package chainQueue;
    
    
    
    public class CQNode {
        CQNode next;
        Object object;
    
        public CQNode(CQNode next,Object object){
            this.next=next;
            this.object=object;
        }
    
        public void setNext(CQNode next){
            this.next=next;
        }
    
        public CQNode getNext(){
            return next;
        }
    
        public void setObject(Object object){
            this.object=object;
        }
    
        public Object getObject(){
            return object;
        }
    
    
    }
    package chainQueue;
    
    
    public class LinkQueue implements ICQueue {
    
         CQNode front;
         CQNode rear;
    
        int size=0;
    
        //初始化
        public LinkQueue(){
            front=rear=null;
        }
    
        @Override
        public boolean isEmpty() {
            return size==0?true:false;
        }
    
        @Override
        public boolean addQueue(Object object) {
            if (size==0){
                front=new CQNode(null,object);
                rear=front;
                size++;
                return true;
            }
            CQNode n=new CQNode(null,object);
            rear.setNext(n);
            rear=n;
            return true;
        }
    
        @Override
        public boolean deleteQueue() {
            if (isEmpty()){
                System.out.println("队列为空!");
                return false;
            }
            front = front.next;
            size--;
            return true;
        }
    
    
        public static void main(String[] args)throws  Exception{
            LinkQueue linkQueue=new LinkQueue();
    
            linkQueue.addQueue(1);
            linkQueue.addQueue(2);
            linkQueue.addQueue(3);
            linkQueue.addQueue(4);
            System.out.println("队列长度为:"+linkQueue.size);
            linkQueue.deleteQueue();
        }
    }
    

     

  3. 实现一个循环队列
    package circularQueue;
    
    public class CirQueue {
        /*
        * 数组实现的循环队列,需要注意的一点,
        * 当队列为空和满的时候,我们需要去区别一下,
        * 因为,在队列为满的时候我们牺牲掉一个空间,使得rear的下一个位置为front,用来区分
        * */
    
        Object[] queue;
        int front;
        int rear;
    
        public CirQueue(){
            /*
            * 调用有参的构造方法
            * */
            this(10);
        }
    
        public CirQueue(int size){
            queue=new Object[size];
            front=0;
            rear=0;
        }
    
        /*
        * 入队
        * */
        public boolean enter(Object o){
            if((rear+1)%queue.length==front){
                System.out.println("队列已满!");
                return false;
            }
    
            queue[rear]=o;
            rear=(rear+1)%queue.length;
            return true;
    
        }
    
        /*
        * 出队
        * */
        public Object depaeure(){
            if (rear==front){
                return null;
            }
            Object o=queue[front];
            front=(front+1)%queue.length;
            return o;
        }
    
    
        public static void main(String[] args)throws Exception{
            CirQueue cirQueue=new CirQueue(5);
            cirQueue.enter("张三");
            cirQueue.enter("李四");
            cirQueue.enter("王五");
            cirQueue.enter("赵六");
            //当这里入队时,最后的位置为空,队列已满
            cirQueue.enter("孙七");
    
    
            for (int i = 0; i <5 ; i++) {
    
                System.out.println("出队元素为:"+cirQueue.depaeure());
            }
        }
    }
    

     

字节跳动消息队列深度剖析:从BMQ架构到重复消费实战 消息队列作为分布式系统的核心基础设施,承担着解耦、异步、削峰填谷的关键职责。从Kafka到自研BMQ,字节跳动通过存储计算分离架构与EC纠删码技术解决了海量数据下的存储成本与扩展性难题。深入理解Topic、Partition、Consumer Group与Offset机制,是掌握消息队列原理的基础。消息重复消费无法完全避免,需通过幂等设计、手动提交Offset等手段兜底。同时,从嵌入式FreeRTOS消息队列到分布式消息中间件,生产者-消费者模型一脉相承。本文结合字节跳动内部实践,剖析消息队列架构演进、重复 阅读详情

相关推荐

数模【Mathematica(安装、入门方法、基本计算、基本图形、创建互动模型、利用数据、幻灯片演示、完整实例)】

Mathematica(安装and激活、入门方法、基本计算、基本图形、创建互动模型、利用数据、幻灯片演示、完整实例) Mathematica_11.3.0 安装教程 Mathematica11.3 激活 P1 笔记本 P2 入门方法 P3 基本计算 P4 基本图形 P5 创建互动模型 P6 利用数据 P7 演示 P8 完整实例

upward 12万+

java 获取queue长度_廖雪峰Java5Java集合-5Queue-1使用Queue

Queue特性和基本方法Queue实现一个先进先出(FIFO, First In First Out)的队列。如收银台排队支付。Java中LinkedList实现了Queue接口,可以直接把LinkedList当作Queue来使用。获取队列长度size()添加元素到队尾boolean add(E e)/boolean offer(E e)获取队列头部元素并删除 E remove()/E poll(...

weixin_33597080的博客 3093

树莓派5首次开机保姆级教程(无显示器通过VNC连接树莓派桌面)

选择 Interface Options > VNC > Yes 启用服务。2.在Windows电脑上安装VNC软件。重启树莓派:sudo reboot。3.使用VNC远程访问树莓派桌面。

qq_34184505的博客 2352

C语言 队列(循环队列和链队初始化进出队等基本操作)

循环队列、链队的初始化、进队和出队等基本操作-----

m0_73070900的博客 2万+

深度解析中国支付清算体系

说起国之重器,不仅仅有 东风快递、渔16、渔17、渔18,还有另外一个国之重器-CNAPS2(中国支付清算体系)。 中国国内支付行业的发达水平、繁荣程度,不客气的讲,在全世界都是数一数二的,世界上最大的银行卡组织银联在中国,世界上交易量最大的网络零售支付清算体网联在中国。可以说现在我国经济的高速发展,离不开CNAPS2。

银行信息系统应用架构详解 2526

GD32F470实战:如何用EXMC+SDRAM搞定LVGL大内存需求(附完整代码)

本文详细介绍了如何在GD32F470微控制器上通过EXMC接口驱动外部SDRAM,以满足LVGL图形库的大内存需求。内容涵盖硬件连接、EXMC时序配置、轻量级内存管理器实现,以及将LVGL帧缓冲和资源无缝集成到SDRAM的实战方法,并提供了完整的代码示例和调试技巧,帮助开发者构建稳定可靠的嵌入式GUI系统。

k9l0m1的博客 444

C语言-队列

C语言-队列

qq_64831425的博客 1232

本科双非的计算机考研择校注意点——经验贴

一战一志愿上岸某211的电子信息专硕。之前在某乎也发过帖子。但现在用优快云,所以把相关的心得再发出来仅供大家参考。 首先,我认为最重要的是你为什么要考研? 不管你是为了混一个文凭将来好进大厂,还是为了真正搞学术或者学知识,你要知道你自己的目标,只有坚定自己的目标,才有动力去走完这段复习的历程。真正的考研,是很苦的。如果你是为了逃避大四面临的就业才选择考研,并且还浑浑噩噩不当回事,那我劝你放弃,不如踏踏实实学点技术去找实习。那从我自己出发,我是认为自己本科双非院校且自己四年间没有学到什么专业方面的技能,

m0_56698268的博客 3167

队列的实现(C语言)

队列的定义队列的顺序存储-->循环队列方案1:牺牲一个单元来区分队空和队满方案2:增设表示元素个数的变量(不牺牲存储单元)方案3:增设tag数据成员区分队空队满(不牺牲存储单元)链式队列的实现带头结点的链式队列不带头结点的链式队列 队列的定义 队列(Queue) 是一种操作受限的线性表,只允许在表的一端进行插入,而在表的另一端进行删除。 队列操作的特性:先进先出(Frist In First Out) 队列的顺序存储–>循环队列 方案1:牺牲一个单元来区分队空和队满 实现: // .

qq_931027577 1万+

西门子 S7-200 SMART 系列六:手把手教你配置S7-200 SMART Modbus RTU

最新发表:https://www.ics-pedia.com/%e8%a5%bf%e9%97%a8%e5%ad%90-s7-200-smart-%e7%b3%bb%e5%88%97%e5%85%ad%ef%bc%9a%e6%89%8b%e6%8a%8a%e6%89%8b%e6%95%99%e4%bd%a0%e9%85%8d%e7%bd%aes7-200-smart-modbus-rtu%e5%ae%9e%e4%be%8b/

John_09040211的博客 3284

清理异常值(MAD:绝对中位差)

清理异常数据: 中位数绝对偏差(MAD):用来描述单变量样本在定量数据中可变的一种标准 在统计学中,绝对中位差是刻画一元数据样本变化的一个鲁棒度量。由公式可以看出,其求解还算简单,给定一个数据样本集,首先求其中位数,然后求原始数据减去中位数的绝对值从而形成一个新的数据样本,再求新的数据样本的中位数即为绝对中位差。比如说有一个数据样本集X={2 3 8 7 9 6 4},这时候数据的中位数是6,原...

spider_man 1万+

java编程 队列_【数据结构】之队列的java实现(一)详解

队列的定义:队列(Queue)是只允许在一端进行插入,而在另一端进行删除的运算受限的线性表。 (1)允许删除的一端称为队头(Front)。(2)允许插入的一端称为队尾(Rear)。(3)当队列中没有元素时称为空队列。(4)队列亦称作先进先出(First In First Out)的线性表,简称为FIFO表。队列的修改是依先进先出的原则进行的。新来的成员总是加入队尾,每次离开的成员总是队列头上的(不...

weixin_29876033的博客 268

【量化入门】Tushare库获取公募基金的历史净值

在本文中,我们将介绍如何使用Python的Tushare库获取公募基金的历史净值。

木头大左的博客 1146

JAVA并发编程随笔【一】PriorityBlockingQueue优先级队列

一、优先级队列PriorityBlockingQueue必须是实现Comparable接口,队列通过这个接口的compare方法确定对象的priority。当前和其他对象比较,如果compare方法返回负数,那么在队列里面的优先级就比较搞       比较规则:当前对象和其他对象做比较,当前优先级大就返回-1,优先级小就返回1   二、优先级队列是一个基于堆的无界并发安全的优先级队列。 ...

OceanSky的专栏 8499

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

《Java 编程的逻辑》笔记——第11章 堆与优先级队列(一)

文章目录开头语11.1 堆的概念与算法11.1.1 基本概念11.1.1.1 完全二叉树11.1.1.2 编号与数组存储11.1.1.3 最大堆/最小堆11.1.1.4 堆概念总结11.1.2 堆的算法11.1.2.1 添加元素11.1.2.2 从头部删除元素11.1.2.3 从中间删除元素11.1.2.4 构建初始堆11.1.2.5 查找和遍历11.1.2.6 算法小结11.1.3 小结 声明: 本博客是本人在学习《Java 编程的逻辑》后整理的笔记,旨在方便复习和回顾,并非用作商业用途。 本博客已标明

bm1998 202

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

Java实现阻塞队列

import java.util.LinkedList; import java.util.Queue; import java.util.Timer; import java.util.TimerTask; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class Bl.

m0_37732829的博客 137

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

《Java并发编程的艺术》第六章 Java中的阻塞队列 思维导图

Rush6666的博客 198

军训队列问题,Java版

题目描述 某大学开学进行军训队列训练,将学生从一开始按顺序依次编号,并排成一行横队,训练的规则如下:从头开始一至二报数,凡报到二的出列剩下的依次向前靠拢,再从头开始进行一至三报数,凡报到三的出列,剩下的依次向前靠拢,继续从头开始进行一至二报数。。。以后每次从头开始轮流进行一至二报数、一至三报数直到剩下的人数不超过三人为止。 输入 第一行为组数N,接着为N行学生人数

renjie223的专栏 1657

用栈实现队列

用栈实现队列 使用栈实现队列的下列操作: push(x) – 将一个元素放入队列的尾部。 pop() – 从队列首部移除元素。 peek() – 返回队列首部的元素。 empty() – 返回队列是否为空。 示例: MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 queue.po...

叶落忆痕的博客 235

编程题:构造队列

题目描述小明同学把1到n这n个数字按照一定的顺序放入了一个队列Q中。现在他对队列Q执行了如下程序:while(!Q.empty()) //队列不空,执行循环 { int x=Q.front(); //取出当前队头的值x Q.pop(); //弹出当前队头 Q.push(x); ...

灰太狼 597

java实现队列

队列是一种重要的数据结构,在排队论和算法设计中有很重要的应用,其实队列也是一种链表,它只允许在表的始端出表(dequeue),在表的末端入表(enqueue),下边是队列的java实现。50 //队列是一种重要的数据结构,主要应用是资源的排队(例如打印机),需要注意的是要利用循环数据来存储数据class Queue { private int front; private int ba...

Hi, Sun 130

Structure.Queue 队列(包含顺序队列,链表队列的实现)

Structure.Queue

445

什么是Java优先级队列(Priority Queue)?

1. 定义: 什么是Java优先级队列(Priority Queue)? 基于堆实现的优先级队列:PriorityQueue 解决 Top K 问题 使用PriorityQueue Java学习笔记–PriorityQueue(优先队列)(堆) Java堆结构PriorityQueue完全解析 Java 优先级队列 PriorityQueue 数据结构之优先队列-Java PriorityQue...

dev_zyx的博客 899

java数据结构之循环队列(数组实现)

package com.ws.队列.数组环形队列; //环形数组队列 //判断满:尾+1%队列长度==头 //添加数据:要(尾+1)%数组长度 //取出数据:要(头+1)%数组长度 因为这两个都是循环的,相当于一个圆环,%数组长度就是转圈 //队列有效数据个数:(尾+数组长度-头)%数组长度 数组因为是个圈,所以可能出现头>尾的情况,所以要提前转一圈,保证尾>头 //取数据:i%数组长度 //因为到最后一个时判断空是尾+1然后取余,实际数组最后一个空间存不上,所以

wangshuo2020的博客 278

两个栈实现队列

题目描述 用两个栈实现队列,支持队列的基本操作。 输入描述: 第一行输入一个整数N,表示对队列进行的操作总数。 下面N行每行输入一个字符串S,表示操作的种类。 如果S为"add",则后面还有一个整数X表示向队列尾部加入整数X。 如果S为"poll",则表示弹出队列头部操作。 如果S为"peek",则表示询问当前队列中头部元素是多少。 输出描述: 对于每一个为"peek"的操作,输出一行表示当前队列中头部元素是多少。 示例1 输入 复制 6 add 1 add 2 add 3

有梦的博客 361

队列的引入lqb--摘抄

大佬:队列是很常见的数据结构,它的存取方式是“先进先出”。生活中的排队,就是队列的原型,例如排队买票,先到先服务。 萌新:行了行了,别卖关子了,直接说说它怎么实现吧。 大佬:队列有两种实现方式:链队列和循环队列。 链队列实际上和单向链表一样,用指针把各个结点连接起来。 循环队列使用一组连续的存储单元依次存放队列元素,用指针head指示队列头元素,rear指向尾元素。当head和rear走到底时,下一步回到开始的位置,从而在这组连续空间内循环。设计成循环能解决溢出问题。 如果使用环境简单...

weixin_52634719的博客 664
上一篇: java编程(一)链表
下一篇: java编程(一)栈
vegetableChick
博客等级 码龄11年 7粉丝 19原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值