java-队列--黑马

news2024/11/15 7:57:25

队列

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

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

队列接口定义

// 队列的接口定义
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;
}

}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2071444.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

河南萌新联赛2024第（六）场：郑州大学

河南萌新联赛2024第（六）场：郑州大学

目录 A-装备二选一&#xff08;一&#xff09;_河南萌新联赛2024第&#xff08;六&#xff09;场&#xff1a;郑州大学 (nowcoder.com) 思路&#xff1a; 代码&#xff1a; B-百变吗喽_河南萌新联赛2024第&#xff08;六&#xff09;场&#xff1a;郑州大学 (nowcoder.com) …
阅读更多...
3DsMax将两个模型的UV展到一个UV上面

3DsMax将两个模型的UV展到一个UV上面

3DsMax将两个模型的UV展到一个UV上面 3Dmax中的准备工作 创建一个方块&#xff0c;一个球体&#xff0c;模拟两个模型 添加修改器 打开UV编辑器&#xff0c;快速剥 使用缩放工具&#xff0c;缩放UV&#xff0c;放到一个位置 选择正方形&#xff1a;添加修改器&#xff0…
阅读更多...
8.3 数据库基础技术-关系代数

8.3 数据库基础技术-关系代数

并、交、差 笛卡尔积、投影、选择 自然连接 真题
阅读更多...
宝塔面板配置node/npm/yarn/pm2....相关全局变量 npm/node/XXX: command not found

宝塔面板配置node/npm/yarn/pm2....相关全局变量 npm/node/XXX: command not found

1.打开终端 , cd 到根目录 cd / 2.跳转至node目录下,我的node版本是v16.14.2 cd /www/server/nodejs/v16.14.2/bin 2.1 如果不知道自己node版本多少就跳转到 cd /www/server/nodejs 然后查找当前目录下的文件 ls 确定自己的node版本 cd /node版本/bin 3.继续查看bin…
阅读更多...
天润融通助力呷哺呷哺：AI技术赋能3000万会员精细化运营

天润融通助力呷哺呷哺：AI技术赋能3000万会员精细化运营

呷哺集团于1998年11月在北京成立&#xff0c;以“一人一锅”台式小火锅的用餐模式&#xff0c;以及其推出的多样化套餐与良好的用餐服务赢得了众多消费者的青睐&#xff0c;并迅速在市场上占据了一席之地。经过20多年的发展&#xff0c;呷哺呷哺已成为一个多品牌经营、全产业链…
阅读更多...
基于Android的安全知识学习APP的设计与实现(论文+源码)_kaic

基于Android的安全知识学习APP的设计与实现(论文+源码)_kaic

基于Android的安全知识学习APP的设计与实现 摘 要 随着科技的进步&#xff0c;智能手机已经成为人们工作、学习和生活的必需品。基于Android系统的强大功能&#xff0c;使用Java语言、Linux操作系统&#xff0c;搭配Android Studio&#xff0c;并配备Android开发插件&#…
阅读更多...
Unet改进3：在不同位置添加NAMAttention注意力机制

Unet改进3：在不同位置添加NAMAttention注意力机制

本文内容：在不同位置添加NAMAttention注意力机制 目录 论文简介 1.步骤一 2.步骤二 3.步骤三 4.步骤四 论文简介 识别不太显著的特征是模型压缩的关键。然而，它在革命性的注意机制中尚未得到研究。在这项工作中，我们提出了一种新的基于归一化的注意力模块(NAM)，它抑制…
阅读更多...
广州自闭症学校哪家好？

广州自闭症学校哪家好？

在广州&#xff0c;选择一家适合自闭症儿童的康复学校是一个需要慎重考虑的决定。在众多机构中&#xff0c;星启帆自闭症儿童康复机构以其专业的师资团队、全面的康复服务以及温馨的学习环境脱颖而出&#xff0c;成为众多家长信赖的选择。 星启帆自闭症康复中心&#xff0c;作…
阅读更多...
敦煌智旅：Serverless 初探，运维提效 60%

敦煌智旅：Serverless 初探，运维提效 60%

作者&#xff1a; 百潼 行业新趋势 在后疫情时代&#xff0c;文旅行业开始复苏&#xff0c;在行业的发展趋势中&#xff0c;我们看到了一个充满机遇和挑战的未来。通过不断创新和适应市场需求&#xff0c;文旅行业继续不断发展壮大&#xff0c;为消费者提供更加丰富多样的旅游…
阅读更多...
UnQLite：多语言支持的嵌入式NoSQL数据库深入解析

UnQLite：多语言支持的嵌入式NoSQL数据库深入解析

文章目录 1. 引言2. Key/Value 存储接口2.1 关键函数2.2 使用示例2.3 高级操作&#xff1a;批量文件存储 3. 游标的使用4. UnQLite-Python使用示例4. UnQLite数据库引擎架构5.1 Key/Value存储层5.2 文档存储层5.3 可插拔的存储引擎5.4 事务管理器与分页模块5.5 虚拟文件系统 6.…
阅读更多...
右值引用与左值引用

右值引用与左值引用

目录 1. 左值与右值2. 左值引用与右值引用 1. 左值与右值 2. 左值引用与右值引用
阅读更多...
千益畅行，旅游卡，案例分享

千益畅行，旅游卡，案例分享

旅游卡作为新旅游这个赛道&#xff0c;到处都是金矿&#xff0c;看你怎么去挖&#xff0c;商机无限。千益畅行旅游卡作为旅游卡源头&#xff0c;提供优质完善的服务&#xff0c;你只需要去铺卡搞钱&#xff0c;其他的售后交给我们&#xff01; #旅游卡服务#
阅读更多...
使用静态IP为什么比动态IP的人多?

使用静态IP为什么比动态IP的人多?

在网络世界中&#xff0c;IP地址就好比我们的身份证&#xff0c;用来标识我们在互联网上的唯一身份。而静态IP与动态IP&#xff0c;则是这“身份证”的两种不同分配方式。 一、静态IP与动态IP的区别 动态IP&#xff1a;动态IP地址如同租住的公寓&#xff0c;用户每次上网时&a…
阅读更多...
【Qt】常见控件 —— QWidget(下)

【Qt】常见控件 —— QWidget(下)

文章目录 QWidget 的 windowlcon 属性使用 qrc文件管理资源qrc的使用方式在项目中创建 qrc文件把图片 导入到qrc 文件中 QWidget 的 windowOpacity属性 QWidget 的 windowlcon 属性 windowlcon 表示 一个窗口的图标 ( 只能针对 顶层窗口使用 ) windowlcon() 表示 获取到控件的…
阅读更多...
吴恩达机器学习课后作业-05偏差与方差

吴恩达机器学习课后作业-05偏差与方差

偏差与方差 题目欠拟合改进欠拟合影响偏差和方差因素训练集拟合情况训练集和测试集代价函数选择最优lamda 整体代码 训练集:训练模型 验证集︰模型选择&#xff0c;模型的最终优化 测试集:利用训练好的模型测试其泛化能力 #训练集 x_train,y_train data[X],data[ y]#验证集 …
阅读更多...
【C++ Primer Plus习题】4.9

【C++ Primer Plus习题】4.9

问题: 解答: #include <iostream> using namespace std;typedef struct _CandyBar {string brand;float weight;int calorie; }CandyBar;int main() {CandyBar* snack new CandyBar[3];snack[0] {"德芙",2.1,20};snack[1] { "箭牌",2.2,16 };sna…
阅读更多...
鸿蒙（API 12 Beta3版）【使用Image完成图片编码】图片开发指导依赖JS对象

鸿蒙（API 12 Beta3版）【使用Image完成图片编码】图片开发指导依赖JS对象

开发者可以调用本模块的Native API接口&#xff0c;完成图片编码&#xff0c;即将PixelMap压缩成不同格式的存档图片。 当前支持编码为JPEG、WebP 和 PNG 格式。 适用场景 图片编码转换。 通过传入图片源ImageSource&#xff0c;封装成想要的格式。 图片编辑 编辑PixelMap后…
阅读更多...
【C# 】使用List＜实体类＞

【C# 】使用List＜实体类＞

1. 使用List<实体类> 要在C#中使用List<EntityTemp>并实现查找数据输出&#xff0c;首先需要定义EntityTemp类&#xff0c;并创建一个List<EntityTemp>类型的列表。然后&#xff0c;你可以使用LINQ或其他方法来查找和输出数据。 假设EntityTemp类具有一个…
阅读更多...
最新最全的Pytest接口自动化测试框架教程

最新最全的Pytest接口自动化测试框架教程

pytest编写的规则&#xff1a; 1、测试文件以test_开头&#xff08;以_test结尾也可以&#xff09; 2、测试类以Test开头&#xff0c;并且不能带有__init__方法 3、测试函数以test_开头 4、断言必须使用assert pytest.main([-s,-v]) &#xff1a;用来执行测试用例 -s 打印prin…
阅读更多...
pcdn闲置带宽被动收入必看教程。第六讲：交换机配置实战篇

pcdn闲置带宽被动收入必看教程。第六讲：交换机配置实战篇

pcdn闲置带宽被动收入必看教程。第六讲&#xff1a;交换机配置实战篇 本章节将介绍如何通过简单的步骤配置交换机&#xff0c;以汇聚所有宽带并集中管理速率&#xff0c;最终接入服务器或软路由&#xff0c;实现远程管理分配速率给具体的服务器或小主机等。 交换机配置步骤 1…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023