java队列框架_JAVA笔记整理-集合框架-单链表-队列结构-栈结构

最新推荐文章于 2024-03-09 22:41:26 发布
最新推荐文章于 2024-03-09 22:41:26 发布
阅读量241 收藏
点赞数
文章标签： java队列框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_32825467/article/details/114431119
版权

一、集合框架

有关LinkedList的集合的，它是一个链表结构的集合

1、链表结构

1.1 单链表的结构

所谓单链表(Linked)在内存中不连续的一端内存空间， 链表的每一个元素是一个节点，每一个结点由数据元素和下一个结点的存储位置组成，链表结构与数组结构最大区别是链接结构的存储内存是不连续的，而数组结构的内存是连续的，链表结构不能与数组结构一样快速查找，

​链表结构操作特点是 添加，删除元素效率高，查询效率低；

​ 数组结构操作特点： 添加，删除效率低，查询效率高

前驱： 该节点的上一个元素的地址

后继： 该节点的下一个元素的地址

链表结构中最后一个元素的”后继“为null

1.2 单链表的实现

链表实现添加元素：

2d9ad46690204cb3acd0740f810e0d86.png

/**

* 添加到最后元素

* @param obj

*/

public void addLast(Object obj){

//将节点添加到最后

//add(obj , this.size);

// 创建节点

// Node node = new Node(obj);

// // 找到最后一个元素的地址

// Node lastNode = this.header;

// for(int i = 0;i

// lastNode = lastNode.next;

// }

//

// lastNode.next=node;

// 找最后一个结点 (由于最后一个结点的next是null)

Node node = new Node(obj);

Node lastNode = this.header;

while(lastNode.next!=null){

lastNode = lastNode.next;

}

lastNode.next = node;

this.size++;

}

eaba4ad98fc330dd937c60a1ed9a3883.png

/**

* 删除第一个节点

* @param index

* @return

*/

public void removeFirst(){

//删除第一个节点

if(this.size==0){

throw new IllegalArgumentException("没有需要删除的原始");

}

// 获取当前连接的“后继”

Node node = this.header.next;

// 并让后继作为头

this.header = node;

this.size--;

}

/**

* 删除最后节点

*/

public void removeLast(){

//删除是否存在数据

if(this.size==0){

throw new IllegalArgumentException("没有需要删除的原始");

}

// 找最后一个元素的前一个 地址 ，并将该地址的next 改为null

Node cur = this.header;

Node pre = this.header;

while(cur.next!=null){

pre = cur;

// 下一个变为当前

cur = cur.next;

}

// 最后一个元素 就是 当前

pre.next = null;

size--;

}

单链练习：整体

package linked;

import javax.xml.soap.Node;

/**

* @ClassName:JAVA

* @Author:ZhouHongTing

* @pate:2020/10/26 18:47

* @Description;

*/

public class Test {

//创建链表头部

Node header; //如果有节点，那么这就是头节点

int size;//计算链表数量

//创建节点类

class Node{

//节点内容

T data;

Node next;//下一个节点地址

public Node(T data){

this.data=data;

}

//获取data

public T getData(){

return data;

}

//设置data

public void setData(T data){

this.data=data;

}

//获取下一个节点地址

public Node next(){

return next;

}

//设置下一个节点地址

public void setNext(){

this.next=next;

}

}

/**

* 将元素添加到第一个节点

*/

public void addFirst(T n){

//创建节点

Node node=new Node(n);

node.next=this.header;//新节点的后继就是原节点头部

this.header=node;//将头节点变为新要添加的节点

//节点计数器加一

size++;

}

/**

* 添加到最后元素

*/

public void addLast(T n){

//创建新节点

Node node=new Node(n);

Node lastNode=this.header;//创建一个最后节点，赋予头值从头开始算，求出最后节点

while (lastNode.next!=null){

lastNode=lastNode.next;

}

lastNode.next=node;

this.size++;

}

/**

* 插入一个指定下标节点

*/

public void addIndex(T n,int index){

Node node=new Node(n);//创建新节点

Node cle=this.header;//创建 一个前节点获取头节点值作为初始值

Node cur;//创建一个后一个节点，装前一个节点的(下一个节点地址)

for(int i=0;i

cle=cle.next;//循环判断到指定下标的前一个节点

}

cur=cle.next;//将前一个节点的下个节点地址存入

cle.next=node;//前一个节点的下一个节点地址就是当前插入元素节点

node.next=cur;//当前节点的下个节点位置就是原先前节点的下个节点地址

this.size++;

}

/**

* 删除第一个节点

*/

public void removeFirst(){

//先判断是否存在节点

if(this.size==0){

throw new IllegalArgumentException("没有需要删除的节点");

}

//获取当前节点的"后继"

Node node=this.header.next;//获取当前头节点的后继节点

//让后继节点替换头节点便完成删除头节点

this.header=node;

this.size--;

}

/**

*删除一个指定下标节点

*/

public void removeIndex(int index){

// Node node=new Node(n);

if(this.size

throw new IllegalArgumentException("要删除的节点不存在");

}

Node pre=this.header;

Node cur=this.header;

for(int i=0;i

pre=cur;

cur=pre.next;

}

pre.next=cur.next;

this.size--;

}

/**

* 删除最后节点

*/

public void removeLast(){

//判断是否存在节点

if(this.size==0){

throw new IllegalArgumentException("没有节点");

}

//找到最后一个节点的前一个节点，并将它下个节点地址改为null

Node cur=this.header;

// Node pre=header;

while (cur.next!=null){

// pre=cur; //获取的后继节点就是下一个节点

cur=cur.next;//获取节点后继，直到cur.next=null

}

// pre.next=null;

cur.next=null;

this.size--;

}

/**

* 根据下标获取节点

* @param

*/

public Node getShowInfo(int index){

//判断是否为空节点

if(this.size==0){

throw new IllegalArgumentException("这是空节点");

}

if(index==0){

return this.header;

}

//查找指定下标的元素

Node cur=this.header;//从第一个元素开始

int j=0;

while (index!=j&&index

cur=cur.next;

j++;

}

return cur;

}

//测试

public static void main(String[]args){

Test test=new Test();

test.addFirst("hello1");

test.addFirst("hello2");

test.addFirst("hello3");

for(int i=0;i

System.out.println(test.getShowInfo(i).getData());//输出添加的节点元素

}

test.addIndex("hello",1);//在指定位置添加节点元素

System.out.println(test.size); //查看节点数量 //4

test.removeFirst(); //删除第一个节点元素

System.out.println(test.header.getData()); //hellio

test.removeLast(); //删除最后一个节点元素

System.out.println(test.size); //2

System.out.println(test.getShowInfo(test.size-1).getData());//hello2

test.removeIndex(1); //删除指定下标为1 的节点元素

System.out.println(test.size); //1

System.out.println(test.getShowInfo(1).getData()); //hello

}

}

2、队列结构

队列结构(Queue)： 在基于链表结构的基础上 ，实现的一种“先进先出”的结构， 常用操作 入队(put)，出队(pop) ，设置队列的头结点 和 尾结点

d6908b8f49f27d18009c4d3cde42436a.png

package com.j2008.dataStruct;

public class MyQueue {

// 头结点

private Node front;

// 尾结点

private Node tail;

// 大小

private int size;

public MyQueue(){

// 头，尾为空

this.front= this.tail=null;

}

class Node{

private T obj;

private Node next;

public Node(T obj){

this.obj = obj;

}

public T getObj() {

return obj;

}

public void setObj(T obj) {

this.obj = obj;

}

public Node getNext() {

return next;

}

public void setNext(Node next) {

this.next = next;

}

}

/**

* 入队 ： 将元素添加到队列的尾部

*/

public void put(T obj){

// 创建节点

Node node = new Node(obj);

// 如果元素为空 则头就尾，尾就是头

if(isEmpty()){

this.front = this.tail = node;

return ;

}

// 将新元素的地址 作为尾的next

this.tail.next=node;

//将新元素的结点 作为尾节点

this.tail = node;

this.size++;

}

/**

* 出队： 将元素从队列的头部移除 (保持与队列脱离关系)

* @return

*/

public T pop(){

if(isEmpty()){

throw new IllegalArgumentException("没有可出队的元素");

}

// 移除头部元素

Node popNode = this.front;

// 设置现在的头元素是下一个

this.front = popNode.next;

// 将弹出的元素next 设置null，与队列脱离关系

popNode.next=null;

this.size--;

// 如果没有元素了 则需要 设置头尾都是null

if(this.size<0){

this.front=this.tail=null;

}

return popNode.getObj();

}

/**

* 判断元素是否为空

* @return

*/

public boolean isEmpty(){

if(this.front==null && this.tail==null){

return true;

}

return false;

}

}

队列结构整体练习：

package linked;

/**

* @ClassName:JAVA

* @Author:ZhouHongTing

* @pate:2020/10/27 9:08

* @Description;

*/

public class Test2 {

//创建头部结点

private Node front;

//创建尾部结点

private Node tail;

//创建结点计数器

int size=0;

public class Node{

//创建结点元素，装纳内容

private T Info;

//创建下一个节点地址对象

Node next;

public Node(T info) {

this.Info = info;

}

public T getInfo() {

return Info;

}

public void setInfo(T info) {

this.Info = info;

}

}

/**

* 入队

*/

public void put(T t){

Node node=new Node(t);

//判断结点是否为空

if(isEmpty()){

front=tail=node; //若都为空，则添加的元素，遵循先进先出，即尾就是头；

}

//若不为空，则新添加的节点元素为尾

tail.next=node;

tail=node;

size++;

}

/**

* 出队

*/

public void out(){

//判断有无结点

if(isEmpty()){

throw new IllegalArgumentException("结点为空");

}

//若不为空，则从头开始出队，即删除头部元素

Node node=front;//获取头结点元素

front=node.next;//将头结点下个结点地址，重新赋值给头结点，即原来的头结点被它的下一个结点覆盖

//将获取的头结点与队列断开联系，即出队,即设置它的下个结点地址为空

node.next=null;

size--;

//当计算器为0时，则头尾皆空

if(this.size<=0){

front=tail=null;

}

}

/**

* 判断结点是否为空

*/

public boolean isEmpty(){

if(front==null&&tail==null){

return true;

}

return false;

}

/**

* 测试

*/

public static void main(String[] args) {

Test2 t=new Test2();

//入队

t.put("hello1");

t.put("hello2");

t.put("hello3");

//输出结点数量

System.out.println(t.size);//3

//输出头结点元素

System.out.println(t.front.Info);//hello

//输出尾结点元素

System.out.println(t.tail.Info);//hello3

//出队

t.out();

System.out.println(t.size);//2

//输出头结点元素

System.out.println(t.front.Info);//hello2

//输出尾结点元素

System.out.println(t.tail.Info);//hello3

}

}

3、栈结构

栈(Stack)结构也是常用数据结构之一，它具有 “后进先出” 的特点

24cb38e7c90800869105a0e88dc1a25d.png

public class MyStack {

// 定义一个数组 ，用于存储元素

private Object[] obj;

private int size;

public MyStack(){

obj = new Object[10];

size=0;

}

/**

* 入栈： 压入栈顶元素

* @param t

*/

public void push(T t){

expandCapacity(size+1);

obj[size]=t;

size++;

}

/**

* 返回栈顶元素：peek

*/

public T peek(){

if(size>0) {

return (T) obj[size - 1];

}

return null;

}

/**

* 出栈： 返回栈顶的元素，并删除该元素

* @return

*/

public T pop(){

T t = peek();

if(size>0) {

// 将最后一个元素 删除

obj[size - 1] = null;

size--;

}

return t;

}

/**

* 是否为空元素

* @return

*/

public boolean isEmpty(){

return size==0;

}

/**

* 扩容数组大小 ： 扩容1.5倍

*/

public void expandCapacity(int size){

if(obj.length< size){

// 需要扩容

int length = size*3/2 + 1;

this.obj = Arrays.copyOf(this.obj,length);

}

}

}

链表实现栈结构练习：

package linked;

/**

* @ClassName:JAVA

* @Author:ZhouHongTing

* @pate:2020/10/27 9:53

* @Description;

*/

public class Test3 {

//创建头部结点

private Node head;

//创建结点计数器

int size;

//创建结点

public class Node{

//创建内容变量

private T Info;

//创建下个结点地址对象

Node next;

public Node(T info) {

Info = info;

}

public T getInfo() {

return Info;

}

public void setInfo(T info) {

Info = info;

}

}

/**

* 入栈

*/

public void put(T t){

//创建新结点元素

Node node=new Node(t);

//每装入一个新结点，都为头结点

//创建一个结点来装纳头结点，然后交换

Node next=head;

head=node; //将新结点设置为头部结点

head.next=next; //将原头结点，设置为现在的头结点的下一个结点地址

size++;

}

/**

* 出栈

*/

public void out(){

//入栈出栈，先进后出

//判断是否为空结点

if(size==0){

throw new IllegalArgumentException("结点为空");

}

//创建一个结点来装入头部结点，出栈的第一个元素

Node node=head;

head=node.next; //将头结点的下一个结点地址元素设置为新的头部

//设置原先头结点的下个结点地址为空，切断与栈的练习，出栈

node.next=null;

size--;

}

/**

* 输出指定下标结点元素

*/

public Node showInfo(int index){

//判断是否为空

Node pre=this.head;

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

throw new IllegalArgumentException("没有结点");

}

for(int i=0;i

pre=pre.next;

}

return pre;

}

/**

* 测试

*/

public static void main(String[] args) {

//入栈

Test3 t=new Test3();

t.put("hello1");

t.put("hello2");

t.put("hello3");

t.put("hello4");

//测试

for (int i=0;i

System.out.println(t.showInfo(i).Info);

}

//出栈

t.out();

t.out();

// System.out.println(t.showInfo(2).Info);

System.out.println(t.size);

//测试

for (int i=0;i

System.out.println(t.showInfo(i).Info);

}

}

}

结果：

299fee2f97ade102ab62b645c08168c0.png

Wergulskerchkov
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数组结构栈和链表结构栈(两种push方式),分别实现先入后出的有序列表
qq_42035161的博客
08-24 588
数组结构栈和链表结构栈(两种链表结构),分别实现先入后出的有序列表
Java集合框架分析（Queue)——队列体系结构
qq_42274445的博客
03-17 766
Java中的常用队列
Archiea的博客
01-16 3万+
简述了队列的概念以及java中常见的队列，并阐述了各队列的区别与联系。
Java内置队列和高性能队列Disruptor
weixin_54828627的博客
03-01 1333
Disruptor是英国外汇交易公司LMAX开发的一个高性能队列，研发的初衷是解决内存队列的延迟问题。与Kafka、RabbitMQ用于服务间的消息队列不同，disruptor一般用于线程间消息的传递。基于Disruptor开发的系统单线程能支撑每秒600万订单。disruptor适用于多个线程之间的消息队列，作用与ArrayBlockingQueue有相似之处。
Java集合框架：优先级队列、PriorityQueue详解
weixin_64874291的博客
06-27 4036
堆的本质就是一颗完全二叉树，如上图所示；用顺序存储的方式来进行存储（如果是非完全二叉树，不宜采用顺序方式来存储数据，此时会有数组空间的浪费）。大根堆如果一组数据集合中的所有的元素按照完全二叉树的顺序存储方式来进行存储，并且根节点都大于左右孩子节点，此时这个就称作大根堆。小根堆和大根堆类似，本质也是用顺序存储的方式存储的一颗二叉树，并且根节点小于左右孩子节点，此时称作这个堆为小根堆。而优先级队列的本质就是一个大根堆或者小根堆。
Java集合框架：队列、Queue和Deque详解
weixin_64874291的博客
06-18 6623
前言队列是一种数据结构，在Java集合框架中，有对应的实现的接口，
java类集框架——Queue队列
floating_fight的博客
03-28 354
队列是一种先进先出(First In First Out，FIFO)的线性数据结构，所有的数据通过队列尾部进行添加，而后在通过队列前端进行取出。 常用方法 public boolean add(E e) //向队列尾部添加数据，数据添加成功则返回true. public boolean offer(E e) //向队列尾部添加数据，超过队列容量时返回false. public E...
消息队列选型指南：轻松理解常见消息队列和框架（RabbitMQ、ActiveMQ、Apache Kafka）
最新发布
silenceallat的博客
03-09 674
选择消息队列就像是为你的企业选择一个合适的物流系统。你需要考虑货物的类型（消息的性质）、运输的距离（消息的延迟要求）、运输的成本（系统的成本），以及是否需要跟踪货物（消息的持久化需求）等因素。每种消息队列都有其特点和适用场景，没有绝对的“最好”选择，只有最适合你当前需求的选择。
Java的Fork/Join框架
hhh_2333
10-24 403
Doug Lea 的 A Java Fork/Join Framework论文 在有一类并发编程中，问题被（递归地）分解为多个子问题，每个子问题被并发处理，所有子问题结果的组合则是该问题的解决结果。Fork/Join框架可以支持该类并发编程，其主要的实现技术围绕高效构建和管理任务队列和工作线程。
消息队列框架技术选型
六六的小帅的博客
03-20 645
Kafka、rocketmq、rabbitmq优劣势比较、消息队列技术选型
分布式任务调度框架 集合
07-08
1. TBSchedule 一个简洁的分布式任务调度引擎 官方出处 http://code.taobao.org/p/tbschedule/wiki/index/ 2. DISchedule 对TBSchedule分布式任务调度进行了简单改造 3. light-task-scheduler LTS是一个轻量级分布式任务调度框架。有三种角色, JobClient, JobTracker, TaskTracker。 4. uncode-schedule 基于zookeeper+spring task的分布式任务调度组件，非常小巧，无需任何修改就可以使spring task具备分布式特性，确保所有任务在集群中不重复，不遗漏的执行。 5.Quartz 官方地址：http://www.quartz-scheduler.org/downloads 另外付(2.2.1版本的官方说明文档) 目前主流的分布式任务调度框架 个人建议用Quartz 文档全资料多 不过看自己项目需求把 TBSchedule和uncode-schedule基于zookeeper 不用数据库 总之每个框架有各自的优缺点，需求自己略做验证。 附件中有项目的下载地址 可以随时跟新到最新版本和资料。
c语言数据结构-栈队列数组完美版资料.ppt
11-14
本资源摘要信息主要关于C语言数据结构中的栈、队列和数组三个基本概念。栈是一种特殊的线性表，栈的定义是只能在一端插入和删除元素的线性表，特点是后进先出（LIFO）。栈的基本运算包括初始化、判栈空、判栈满、读...
数据结构作业：第三章-栈和队列题目.docx
12-17
数据结构作业：第三章-栈和队列题目 本文档旨在提供一个详细的知识点总结，涵盖数据结构第三章中的栈和队列概念。通过对题目的逐一分析，我们将对栈和队列的基本概念、特点、操作和应用进行总结。 栈的基本概念 ...
数据结构作业：第三章-栈和队列作业答案.docx
12-14
"数据结构作业：第三章-栈和队列作业答案.docx" 本资源摘要信息是关于数据结构第三章栈和队列的作业答案，涵盖了栈和队列的基本概念、操作原则、特点及应用场景。下面是对该资源的详细解读： 1. 栈的操作原则 栈...
数据结构-队列实验报告.docx
11-29
在实现链队列时，我们使用了单链表的数据结构，使用typedef struct 定义了 QNode 结构体，包括数据域和指针域。然后定义了 LinkQueue 结构体，包括队头指针和队尾指针，并实现了链队列的基本操作。 Status ...
数据结构-队列(Queue)介绍和Java示例代码
07-01
队列是一种重要的线性数据结构，它遵循先进先出（FIFO）的规则，即最先插入的元素将最先被移除。在计算机科学中，队列广泛应用于各种算法和程序设计中，尤其在处理需要顺序处理任务的场景下。在Java中，队列可以借助...
消息队列（RabbitMQ）
xue_yun_xiang的博客
06-23 2441
一、概述 消息队列作用：解耦、异步、削峰 解耦 解耦，就是将连个应用不是互相之间强依赖关系，一个挂了，两外一个依然可以使用 削峰 削锋，就是可以将高并发的网络请求 缓存到消息队中，慢慢的执行消息对对应的业务 618 秒杀购买商品 生成订单 扣减库存 扣减余额 发货，生成物流 如果以上 步骤都在一个应用的请求中去执行，在每秒 50000个并发的情况下，是否回对应服务造成很大的压力 优化流程 1.先扣减库存 2将对应商品生成订单的消息，发送到消息队列 3.让应用慢的消费消息 完成一下业务
2021年五面蚂蚁，从基础到源码统统帮你搞定，实战解析
m0_56004877的博客
03-15 963
开头 关于程序员，除了做项目、看视频来提高自身的技术之外，还有一种提升自己的专业技能就是：多！看！书！MySQL俨然已经成为了IT技术人员必须掌握的核心技能之一！ 《MySQL从入门到精通》 本书详细介绍了如何安装、管理、备份、维护和优化一个 MySQL 系统。对于每一件服务器操作都提出了多种的解决方案。对于每一种的方法，虽然不一定都是非常实用的方法，读者能通过这些方法，熟悉 MySQL 的特点和强大的功能。 第一章简单介绍了 MySQL 的历史、特点，同时对 SQL 的语法进行了简单的介绍。如果读者对第一
Java架构之消息队列 （一）：消息队列的概述
热门推荐
acaoye的专栏
10-08 3万+
消息队列系列分享大纲：  一、消息队列的概述 二、消息队列之RabbitMQ的使用 三、消息队列之Kafka的使用 四、消息队列之RabbitMQ的原理详解 五、消息队列之Kafka的原理详解 六、消息队列之面试集锦 1.消息队列的概述 消息队列（Message Queue）中间件是分布式系统中重要的组件； 主要解决应用耦合，异步消息，流量削锋等问题； 实现...
java迷宫队列实现_迷宫问题--队列实现
06-11
Java中可以使用队列来实现迷宫问题的解法。具体的实现步骤如下： 1. 定义一个队列，用于存储走过的路径。 2. 将起点加入队列中，表示从起点开始走。 3. 当队列不为空时，取出队首的路径，并向四个方向扩展路径。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值