java-队列--黑马

已于 2024-08-24 22:28:22 修改
阅读量378 收藏 2
点赞数 6
文章标签： java javascript 开发语言
于 2024-08-24 22:25:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49326024/article/details/141506402
版权

队列

别看这个，没用，还是多刷力扣队列题
定义

队列是以顺序的方式维护一组数据的集合，在一端添加数据，从另一端移除数据。一般来讲，添加的一端称之尾，而移除一端称为头 。

队列接口定义

// 队列的接口定义
public interface Queue<E> {
    
    // 向队尾添加元素
    // 添加成功，返回true; 添加失败返回 false  
    boolean offer(E value);
    
    // 获取头部元素，并移除元素
    E poll();
    
    // 获取头部元素，不移除
    E peek();
    
    // 判断队列是否为空
   	boolean isEmpty();
    
    // 判断队列是否满
    boolean isFull();
}

实现队列

链表实现

使用单向循环带哨兵链表实现队列
在这里插入图片描述

public class LinkedListQueue<E> implements Queue<E>, Iteable<E> {
    
    private static class Node<E> {
        E value;
        Node next;
        
        public Node(E value, Node<E> next) {
            this.value = value;
            this.next = next;
        }
    }
    
    Node<E> head = new Node(null, null);	// 哨兵头
    Node<E> tail = head;					// 哨兵尾
    private int size;
    private int capacity;
    
    public LinkedListQueue(int capacity) {
        this.capacity = capacity;
        tail.next = head;
    }
    
    
    public LinkedListQueue() {
        tail.next = head;
    }
    
    
    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        Node<E> added = new Node<>(value, head);
        tail.next = added;
        tail = add;
        size++;
        return true;
    }
    
    @Ovrride
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        Node<E> first = head.next;
        head.next = first.next;
        if (first == tail) {
            tail = head;
        }
        size--;
        return first.value;
    }
    
    @Override
    pulic E peek() {
        if (isEmpty()) {
            return null;
        }
        return head.next.value;
    }
    
    @Override
    public boolean isEmpty() {
        return head == tail;
    }
    
    @Override 
    public boolean isFull() {
        return size == capacity;
    }
    
    
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            Node<E> p = head.next;
            
            @Override
            public boolean hasNext() {
                return p != head;
            }
            
            @Override
            public E next() {
                E value = p.value;
                p = p.next;
                return value;
            }
        }
    }
}

环形数组实现

方法一
public class ArrayQueue<E> implements Queue<E>, Iterable<E> {
    private E[] array;
    private int head = 0;
    private int tail = 0;
    
    public ArrayQueue(int capacity) {
        array = (E[]) new Object[capacity + 1];
    }
    
    // 添加元素
    @Override
    public boolean offer(E value) {
        // 判断队列是否满
        if (isFull()) {
            return false;
        }
        array[tail] = value;
        tail = (tail + 1) % array.length;
        return true;
    }
    
    // 移除队列头部元素，并返回
    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        E value = array[head];
        head = (head + 1) % array.length;
        return value;
    }
    
    // 获取队列头部元素
    @Override
    public E peek() {
        if(isEmpty()) {
            return null;
        }
        return array[head];
    }
    
    @Override
    public boolean isEmpty() {
        return head == tail;
    }
    
    @Override
    public boolean isFull() {
        return (tail + 1) % array.length == head;
    }
    
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;
            
            @Override
            public boolean hasNext() {
                return p != null;
                // return (p + 1) $ array.length != head;  是对的吗？
            }
            
            @Override
            public E next() {
                E value = array[p];
                p = (p + 1) % array.length;
                return value;
            }
        }
    }
}
方法二 – 修改方法一

添加size变量判断队列是否为空或者为满的情况

public class ArrayQueue2<E> implements Queue<E>, Iterable<E> {
    private E[] array;
    private int head = 0;
    private int tail = 0;
    private int size = 0;
    
    public ArrayQueue2(int capacity) {
        array = (E[]) new Object[capacity + 1];
    }
    
    // 添加元素
    @Override
    public boolean offer(E value) {
        // 判断队列是否满
        if (isFull()) {
            return false;
        }
        array[tail] = value;
        tail = (tail + 1) % array.length;
        size++;
        return true;
    }
    
    // 移除队列头部元素，并返回
    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        E value = array[head];
        head = (head + 1) % array.length;
        size--;
        return value;
    }
    
    // 获取队列头部元素
    @Override
    public E peek() {
        if(isEmpty()) {
            return null;
        }
        return array[head];
    }
    
    @Override
    public boolean isEmpty() {
        return size == 0;
    }
    
    @Override
    public boolean isFull() {
        return size = array.length;
    }
    
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;
            int count = 0;
            @Override
            public boolean hasNext() {
                return count < size;
            }
            
            @Override
            public E next() {
                E value = array[p];
                p = (p + 1) % array.length;
                count++;
                return value;
            }
        }
    }
}
方法三
public class ArrayQueue3<E> implements Queue<E>, Iterable<E> {
    private final E[] array;
    private int head = 0;
    private int tail = 0;
    
    public ArrayQueue(int capacity) {
        array = (E[]) new Object[capacity];
    }
    
    // 添加元素
    @Override
    public boolean offer(E value) {
        // 判断队列是否满
        if (isFull()) {
            return false;
        }
        array[tail & array.length] = value;
        tail = tail + 1;
        return true;
    }
    
    // 移除队列头部元素，并返回
    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        E value = array[head % array.length];
        head = head + 1;
        return value;
    }
    
    // 获取队列头部元素
    @Override
    public E peek() {
        if(isEmpty()) {
            return null;
        }
        return array[head % array.length];
    }
    
    @Override
    public boolean isEmpty() {
        return head == tail;
    }
    
    @Override
    public boolean isFull() {
        return tail - head == array.length;
    }
    
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;
            
            @Override
            public boolean hasNext() {
                return p != tail;
            }
            
            @Override
            public E next() {
                E value = array[p % array.length];
                p++;
                return value;
            }
        }
    }
}

改进算法，防止数组越界

  • 前提是数组容量必须是2的n次方
public class ArrayQueue3<E> implements Queue<E>, Iterable<E> {
    private final E[] array;
    private int head = 0;
    private int tail = 0;
    
    public ArrayQueue(int capacity) {
        array = (E[]) new Object[capacity];
    }
    
    // 添加元素
    @Override
    public boolean offer(E value) {
        // 判断队列是否满
        if (isFull()) {
            return false;
        }
        array[tail & array.length - 1] = value;
        tail = tail + 1;
        return true;
    }
    
    // 移除队列头部元素，并返回
    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        E value = array[head % array.length - 1];
        head = head + 1;
        return value;
    }
    
    // 获取队列头部元素
    @Override
    public E peek() {
        if(isEmpty()) {
            return null;
        }
        return array[head % array.length - 1];
    }
    
    @Override
    public boolean isEmpty() {
        return head == tail;
    }
    
    @Override
    public boolean isFull() {
        return tail - head == array.length;
    }
    
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;
            
            @Override
            public boolean hasNext() {
                return p != tail;
            }
            
            @Override
            public E next() {
                E value = array[p % array.length - 1];
                p++;
                return value;
            }
        }
    }
}

二叉树层序遍历

使用队列

public class Leetcode102{
    
    
    public static void main(String[] args) {
        TreeNode root = new TreeNode(
            new TreeNode(new TreeNode(4), 
                         2, 
                         new TreeNode(5)),
            1,
            new TreeNode(new TreeNode(6), 
                		3, 
                		new TreeNode(7)));
        
        LinkedListQueue<TreeNode> queue = new LinkedListQueue<>();
        queue.offer(root);
        
        while (!queue.isEmpty()) {
            TreeNode n = queue.poll();
            System.out.println(n);
            if (n.left != null) {
                queue.offer(n.left);
            }
            if (n.right != null) {
                queue.offer(n.right);
            }
        }
    }
}

在此基础上实现分层效果
在这里插入图片描述

public class Leetcode102{
    
    
    public static void main(String[] args) {
        TreeNode root = new TreeNode(
            new TreeNode(new TreeNode(4), 
                         2, 
                         new TreeNode(5)),
            1,
            new TreeNode(new TreeNode(6), 
                		3, 
                		new TreeNode(7)));
        
        LinkedListQueue<TreeNode> queue = new LinkedListQueue<>();
        queue.offer(root);
        int c1 = 1;
        while (!queue.isEmpty()) {
            int c2 = 0;
            for(int i = 0; i < c1; i++) {
                
                TreeNode n = queue.poll();
                System.out.print(n + " ");
                if (n.left != null) {
                    queue.offer(n.left);
                    c2++;
                }
                if (n.right != null) {
                    queue.offer(n.right);
                    c2++;
                }
            }
            System.out.println();
            c1 = c2;
        }
    }
}

力扣102题的实现

public class Leetcode102{
    
    
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        
        if (root == null) {
            return res;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int c1 = 1;
        while (!queue.isEmpty()) {
            int c2 = 0;
            List<Integer> list = new ArrayList<>();
            for(int i = 0; i < c1; i++) {
                
                TreeNode n = queue.poll();
                list.add(n.val);
                if (n.left != null) {
                    queue.offer(n.left);
                    c2++;
                }
                if (n.right != null) {
                    queue.offer(n.right);
                    c2++;
                }
            }
            res.add(list);
            c1 = c2;
        }
        return res;
    }
}

        List<Integer> list = new ArrayList<>();
        for(int i = 0; i < c1; i++) {
            
            TreeNode n = queue.poll();
            list.add(n.val);
            if (n.left != null) {
                queue.offer(n.left);
                c2++;
            }
            if (n.right != null) {
                queue.offer(n.right);
                c2++;
            }
        }
        res.add(list);
        c1 = c2;
    }
    return res;
}

}
莫陌尛.
关注
  • 6
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
黑马点评--Redis消息队列
weixin_53050118的博客
11-24 642
不过要注意的是，当队列中没有消息时RPOP或LPOP操作会返回null，并不像JVM的阻塞队列那样会阻塞并等待消息。修改之前的秒杀下单Lua脚本，在认定有抢购资格后，直接向stream.orders中添加消息，内容包含voucherId，userId，orderId。消息队列（Message Queue），字面意思就是存放消息的队列。Stream是Redis5.0引入的一种新数据结构，可以实现一个功能完善的消息队列。消息队列（Message Queue），字面意思就是存放消息的队列。
RabbitMQ笔记-黑马
qq_59961910的博客
04-29 799
建立connection创建channel利用channel声明队列利用channel向队列发送消息建立connection创建channel利用channel声明队列定义consumer的消费行为handleDelivery()利用channel将消费者与队列绑定多个消费者绑定到一个队列，同一条消息只会被一个消费者处理通过设置prefetch来控制消费者预取的消息数量交换机的作用是什么？接收publisher发送的消息将消息按照规则路由到与之绑定的队列。
java-进阶-2
weixin_51480322的博客
03-26 936
day08_日志框架、阶段项目 1、日志框架 01-概述 日志可以用来记录程序运行过程中产生的数据，并且把数据以文件的形式保存起来。一旦程序出现bug，或者出现一些意外的情况，程序员可以通过分析日志文件，来排查问题。 02-日志门面 日志框架有很多种，项目在不同阶段可能需要用到不同的日志。而不同日志的写法又有所不同，如果每次切换都要一个个修改写法，就太令人崩溃了。所以一些组织或者个人提出了日志门面的想法，意思就提供了一套日志相关功能的通用API接口，然后让具体的日志框架去做实现 03-log
java-进阶-1
weixin_51480322的博客
03-26 683
day01-static-代码块-继承-权限修饰符-final 01-static关键字的特点 static 关键字的介绍 static 是静态的意思，可以修饰成员变量，成员方法。被static 修饰的成员在内存中只存储一份，可以被共享，修改 特点 被类的所有对象共享 可以通过类名，直接调用,例如： Student.school 随着类的加载而加载，优先于对象存在 public class StudentTest { public static void main(String
Java-进阶知识
qq_61434231的博客
07-25 343
Java-集合等相关系列知识
Java技术学习|消息队列|初级RabbitMQ
anncyuyan的博客
04-24 914
是非常初级的学习，听说后续的高级课程会涉及到微服务之类的，所以等学完微服务再回来学。还有redis的高级部分也涉及了微服务，所以也都暂时停止学习了。
黑马点评项目-Redis 消息队列
dingd1234的博客
05-03 2317
一、消息队列简介 消息队列（Message Queue），字面意思就是存放消息的队列。最简单的消息队列模型包括 3 个角色： 消息队列：存储和管理消息，也被称为消息代理（Message Broker） 生产者：发送消息到消息队列 消费者：从消息队列获取消息并处理消息 消息队列和阻塞队列的区别： ① 消息队列是在 JVM 以外的独立服务，所以不受 JVM 内存的限制 ② 消息队列不仅仅做数据存储，还需要确保数据安全，存入到消息队列中的所有消息都需要做持久化，这样不管是服务宕机还是重启，数据都不会丢失。而且
黑马SpringBoot --开发篇
D_boj的博客
03-13 1855
目录 笔记小结开启开发者工具添加pom.xml依赖 激活热部署：Ctrl + F9进行编译关于热部署笔记小结设置自动构建项目Settings(设置自动构建项目)1.默认不触发重启的目录列表2.自定义不参与重启排除项(也就是，自定义配置不参与热重启) 9.4关闭热部署 属性加载优先顺序参看https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-exter
java--线程池
weixin_61500949的博客
12-18 371
线程池就是一个可以复用线程的技术。
黑马-JAVA中州养老项目2024语言汇编
05-02
### 黑马-JAVA中州养老项目2024语言汇编知识点概览 #### 一、基础数据开发-服务管理（Day01-Day03） **知识点概述：** 1. **服务管理的设计与实现** - 掌握服务管理模块的架构设计原则。 - 实现基于Java的...
Java项目-黑马斗地主完整Java代码
04-23
【Java项目-黑马斗地主完整Java代码】是一个典型的基于Java编程语言的桌面游戏开发案例，主要用于教授和实践Java编程技巧。在这个项目中，我们能够深入理解Java在游戏开发中的应用，以及相关软件工程的实践。 1. **...
传智播客-黑马32期Java视频
04-12
【标题】"传智播客-黑马32期Java视频" 涉及的知识点主要集中在Java编程语言的学习上，这是由传智播客教育机构推出的系列教程，旨在帮助学员掌握Java开发技能。传智播客是知名的IT教育品牌，其“黑马程序员”系列课程...
xc-framework-parent：黑马-学成在线项目
02-20
"xc-framework-parent：黑马-学成在线项目" 是一个基于Java技术栈的开源框架，用于构建高效、可扩展的在线教育平台。这个项目的核心目标是为开发者提供一套完整的解决方案，帮助快速搭建类似于黑马程序员或学成在线...
阿里云服务器 篇七：服务器热备份/定时备份
生活在别处
08-24 197
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
启动Application 报错：no mapping for GET /（已解决）
最新发布
qq_3512323979的博客
08-26 275
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 697
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 1206
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 1089
linux上datax 安装以及使用
java迷宫队列实现_迷宫问题--队列实现
06-11
好的，我可以为您解答这个问题。 Java中可以使用队列来实现迷宫问题的解法。具体的实现步骤如下： 1. 定义一个队列，用于存储走过的路径。 2. 将起点加入队列中，表示从起点开始走。 3. 当队列不为空时，取出队首的路径，并向四个方向扩展路径。 4. 判断扩展出的路径是否是终点，如果是，则返回该路径。 5. 如果不是终点，则将扩展出的路径加入队列中。 6. 重复以上步骤，直到找到终点或者队列为空。 下面是代码实现： ```java import java.util.LinkedList; import java.util.Queue; public class MazeSolver { private static final int[][] DIRECTIONS = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}}; public static int[] solve(int[][] maze, int[] start, int[] end) { int m = maze.length; int n = maze[0].length; boolean[][] visited = new boolean[m][n]; Queue<int[]> queue = new LinkedList<>(); queue.offer(start); visited[start[0]][start[1]] = true; while (!queue.isEmpty()) { int[] cur = queue.poll(); int x = cur[0]; int y = cur[1]; if (x == end[0] && y == end[1]) { return cur; } for (int[] dir : DIRECTIONS) { int newX = x + dir[0]; int newY = y + dir[1]; if (newX >= 0 && newX < m && newY >= 0 && newY < n && !visited[newX][newY] && maze[newX][newY] == 0) { queue.offer(new int[]{newX, newY}); visited[newX][newY] = true; } } } return null; } } ``` 在上面的代码中，我们使用了一个二维数组visited来记录每个位置是否已经访问过，避免重复访问。同时，使用一个二维数组maze来表示迷宫，0表示可以通过的路，1表示障碍。 函数solve接受三个参数，分别是maze表示迷宫，start表示起点，end表示终点。函数返回一个数组，表示从起点到终点的路径。如果不存在这样的路径，则返回null。 希望这个解答能够帮到您！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值