队列-我的基础算法刷题之路（六）

最新推荐文章于 2024-06-15 23:36:03 发布
最新推荐文章于 2024-06-15 23:36:03 发布
阅读量698 收藏 16
点赞数 28
分类专栏： 算法刷题 文章标签： 算法 java 开发语言 蓝桥杯 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62473134/article/details/129778134
版权

在这里插入图片描述

本篇博客旨在整理记录自已对队列的一些总结，以及刷题的解题思路，同时希望可给小伙伴一些帮助。本人也是算法小白，水平有限，如果文章中有什么错误之处，希望小伙伴们可以在评论区指出来，共勉 💪。
本篇文章主要是讲一下基本的队列以及刷题，暂不过多涉及双端、阻塞队列。

文章目录

一、队列的概述

队列(queue) 是以顺序的方式维护的一组数据集合，在一端添加数据，从另一端移除数据。习惯来说，添加的一端称为尾，移除的一端称为头，就如同生活中的排队买商品。队列遵循先入先出、后入后出的基本原则。

队列的基本结构：
1
2
3
4
进队
出队

二、Java队列的特性

队列主要分为阻塞和非阻塞，有界和无界；按功能分：双端队列、优先队列、延迟队列、其他队列
Queue
按阻塞分类
按大小分类
按功能分类
阻塞队列
非阻塞队列
有界队列
无界队列
普通队列
优先队列
双端队列
延迟队列
其他队列

三、Java 队列的基本操作

  • add(E e)：将元素 e 插入到队列末尾，如果插入成功，则返回 true；如果插入失败（即队列已满），则会抛出异常；
  • remove()：移除队首元素，若移除成功，则返回 true；如果移除失败（队列为空），则会抛出异常；
  • remove(Object o)：移除指定的元素，若移除成功，则返回 true；如果移除失败（队列为空），则会抛出异常；
  • offer(E e)：将元素 e 插入到队列末尾，如果插入成功，则返回 true；如果插入失败（即队列已满），则返回 false；
  • poll()：移除并获取队首元素，若成功，则返回队首元素；否则返回 null；
  • peek()：获取队首元素，若成功，则返回队首元素；否则返回 null；
  • isEmpty()：队列是否为空；
  • size()：队列长度；

四、队列的代码实现

定义一个简化的队列接口：

public interface Queue<E> {

    /**
     * 向队列尾插入值
     * @param value 待插入值
     * @return 插入成功返回 true, 插入失败返回 false
     */
    boolean offer(E value);

    /**
     * 从对列头获取值, 并移除
     * @return 如果队列非空返回对头值, 否则返回 null
     */
    E poll();

    /**
     * 从对列头获取值, 不移除
     * @return 如果队列非空返回对头值, 否则返回 null
     */
    E peek();

    /**
     * 检查队列是否为空
     * @return 空返回 true, 否则返回 false
     */
    boolean isEmpty();

    /**
     * 检查队列是否已满
     * @return 满返回 true, 否则返回 false
     */
    boolean isFull();
}

4.1、链表实现

使用单向环形带哨兵链表方式来实现队列

代码：

public class LinkedListQueue<E>
        implements Queue<E>, Iterable<E> {

    private static class Node<E> {
        E value;
        Node<E> next;

        public Node(E value, Node<E> next) {
            this.value = value;
            this.next = next;
        }
    }

    private Node<E> head = new Node<>(null, null);
    private Node<E> tail = head;
    private int size = 0;
    private int capacity = Integer.MAX_VALUE;

    {
        tail.next = head;
    }

    public LinkedListQueue() {
    }

    public LinkedListQueue(int capacity) {
        this.capacity = capacity;
    }

    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        Node<E> added = new Node<>(value, head);
        tail.next = added;
        tail = added;
        size++;
        return true;
    }

    @Override
    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
    public 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;
            }
        };
    }
}

4.2、数组实现

环形数组实现好处：

  1. 对比普通数组，起点和终点更为自由，不用考虑数据移动；
  2. ”环“意味着不会存在【越界】问题；
  3. 数组性能更佳；
  4. 环形数组比较适合实现有界队列、RingBuffer等；

代码：

/* 下标含义：
 * cur 当前指针位置
 * step 前进步数
 * length 数组长度
 */
public class ArrayQueue<E> implements Queue<E>, Iterable<E>{

    private int head = 0;
    private int tail = 0;
    private final E[] array;
    private final int length;

    @SuppressWarnings("all")
    public ArrayQueue(int capacity) {
        length = capacity + 1;
        array = (E[]) new Object[length];
    }

    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        array[tail] = value;
        tail = (tail + 1) % length;
        return true;
    }

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        E value = array[head];
        head = (head + 1) % length;
        return value;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return array[head];
    }

    @Override
    public boolean isEmpty() {
        return tail == head;
    }

    @Override
    public boolean isFull() {
        return (tail + 1) % length == head;
    }

    @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];
                p = (p + 1) % array.length;
                return value;
            }
        };
    }
}

五、刷题

1. 二叉树层序遍历

题目：给你二叉树的根节点 root ，返回其节点值的 层序遍历 。（即逐层地，从左到右访问所有节点）。

输入输出样例：

示例一：
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
示例二：
输入：root = [1]
输出：[[1]]
示例三：
输入：root = [1]
输出：[[1]]

提示：

  • 树中节点数目在范围 [0, 2000] 内
  • -1000 <= Node.val <= 1000

解题代码：

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if(root == null) {
            return result;
        }
        LinkedListQueue<TreeNode> queue = new LinkedListQueue<>();
        queue.offer(root);
        int c1 = 1;		// 本层节点个数
        while (!queue.isEmpty()) {
            int c2 = 0; 	// 下层节点个数
            List<Integer> level = new ArrayList<>();
            for (int i = 0; i < c1; i++) {
                TreeNode node = queue.poll();
                level.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                    c2++;
                }
                if (node.right != null) {
                    queue.offer(node.right);
                    c2++;
                }
            }
            c1 = c2;
            result.add(level);
        }
        return result;
    }

    // 自定义队列
    static class LinkedListQueue<E> {

        private static class Node<E> {
            E value;
            Node<E> next;

            public Node(E value, Node<E> next) {
                this.value = value;
                this.next = next;
            }
        }

        private final Node<E> head = new Node<>(null, null);
        private Node<E> tail = head;
        int size = 0;
        private int capacity = Integer.MAX_VALUE;

        {
            tail.next = head;
        }

        public LinkedListQueue() {
        }

        public LinkedListQueue(int capacity) {
            this.capacity = capacity;
        }

        public boolean offer(E value) {
            if (isFull()) {
                return false;
            }
            Node<E> added = new Node<>(value, head);
            tail.next = added;
            tail = added;
            size++;
            return true;
        }

        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;
        }

        public E peek() {
            if (isEmpty()) {
                return null;
            }
            return head.next.value;
        }

        public boolean isEmpty() {
            return head == tail;
        }

        public boolean isFull() {
            return size == capacity;
        }
    }
}

2. 设计循环队列

题目：设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

  • MyCircularQueue(k): 构造器，设置队列长度为 k 。

  • Front: 从队首获取元素。如果队列为空，返回 -1 。

  • Rear: 获取队尾元素。如果队列为空，返回 -1 。

  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。

  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。

  • isEmpty(): 检查循环队列是否为空。

  • isFull(): 检查循环队列是否已满。

示例：

MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1);  // 返回 true
circularQueue.enQueue(2);  // 返回 true
circularQueue.enQueue(3);  // 返回 true
circularQueue.enQueue(4);  // 返回 false，队列已满
circularQueue.Rear();  // 返回 3
circularQueue.isFull();  // 返回 true
circularQueue.deQueue();  // 返回 true
circularQueue.enQueue(4);  // 返回 true
circularQueue.Rear();  // 返回 4

提示：

  • 所有的值都在 0 至 1000 的范围内；

  • 操作数将在 1 至 1000 的范围内；

  • 请不要使用内置的队列库。

解题代码：

class MyCircularQueue {
    int k, he, ta;
    int[] nums;

    public MyCircularQueue(int _k) {
        k = _k;
        nums = new int[k];

    }
    
    public boolean enQueue(int value) {
        if (isFull()) return false;
        nums[ta % k] = value;
        return  ++ta >= 0;
    }
    
    public boolean deQueue() {
        if (isEmpty()) return false;
        return ++he >= 0;
    }
    
    public int Front() {
        return isEmpty() ?-1 : nums[he % k];
    }
    
    public int Rear() {
        return isEmpty() ? - 1 : nums[(ta - 1) % k];

    }
    
    public boolean isEmpty() {
        return he == ta;
    }
    
    public boolean isFull() {
        return ta - he == k;
    }
}

最后

对各位小伙伴有帮助的话，希望可以点赞❤️+收藏⭐，谢谢各位大佬~~🙌🙌🙌

乌云暮年
关注
  • 28
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 23
    评论
专栏目录
Leetcode-How-What 力扣Leetcode刷题指南
edwardwjz的博客
03-05 2537
Leetcode-How-What 力扣Leetcode刷题指南 About the way how to use Leetcode wisely for preparing the interview and the solutions to some Leetcode problems’. 怎样为准备面试机智聪明的刷题（高效刷题）以及一些题目的题解。 同 github 链接： https:/...
leetcode下载-LeeCodeList:leecode刷题顺序
06-29
我们基础的数据结构和算法就已经差不多了 第二轮 开始做第一轮类别里面中等难度的题目 第三轮 这一轮的题目所代表的算法是比较难的，如果之前没有了解过，直接就刷题会很难，所以，建议把相关算法的理论看一遍，再去...
2020最新-精选基础算法100题（面试必备）
热门推荐
ATFWUS的博客
05-18 28万+
0x01.概述 作为一个程序员，算法能力必不可少，虽然不一定是算法工程师，但是算法还是彰显着个人的编码能力，面试中也经常会被问到，甚至会被要求临场做算法题，所以，还是好好积累吧。 个人其实对算法挺有兴趣的，从3月份开始，陆陆续续刷了一些算法题，把一些有意义的记录下来了，也顺便写了一些题解，个人认为，还是挺有收获的。 之前写了一篇算法文章的目录，不过后来就忘了实时去更新了，于是现在，想把之前做过的一些有意义的算法题分享出来，刚好整理了100篇比较有意义的。希望对大家有所帮助。 0x02.说明 关
算法刷题路线总结与相关资料分享
小新要变强的博客
10-28 6385
算法刷题路线总结，算法题刷题步骤介绍，数据结构与算法相关资料分享~
【刷题】算法基础刷题清单
qq_42581685的博客
12-13 1605
录 一、动态规划 1、线性DP 2、背包问题 3、状态机模型 4、状态压缩DP 5、区间DP 6、树形DP 7、数位DP 二、搜索
python基础-数据结构-leetcode刷题必看-queue---队列-python的底层构建
qq_44511981的博客
05-29 970
python基础-数据结构-leetcode刷题必看-queue---队列-python的底层构建 - deque 双端队列 - Queue 队列 FIFO - LifoQueue 栈 LIFO - PriorityQueue 优先队列 - SimpleQueue 简单队列 FIFO
leetCode刷题基础篇--队列
qq_37362683的博客
07-31 1362
leetCode刷题基础篇-队列
基础算法刷题（2）
LetItBe的博客
02-18 227
剑指 Offer（专项突击版） 剑指 Offer II 023. 两个链表的第一个重合节点 剑指 Offer II 105. 岛屿的最大面积 DFS and BFS 剑指 Offer II 011. 0 和 1 个数相同的子数组 字典和前缀和 剑指 Offer II 001. 整数除法 减法模拟+位运算 4<<3: 4*(23) 数值边界：MaxInt = 231-1 MinInt = - 2**31 剑指Offer09-用两个栈实现队列 11.3 栈和队列: 栈先进后出，队列先进先出
算法刷题0-java知识补充
qq_45488015的博客
04-14 1414
栈是Vector的一个子类，它实现了一个标准的后进先出的栈。堆栈只定义了默认构造函数，用来创建一个空栈。堆栈除了包括由Vector定义的所有方法，也定义了自己的一些方法。常用方法描述：（除了Vector的方法外）
软件工程-基础篇刷题
qq_21575929的博客
04-03 1250
1.操作系统原理 1.1 进程的概念 进程是操作系统管理任务的最小单位。除了进程，还有线程，线程是为了处理进程中更细小的任务，操作系统中的CPU为了处理线程中的任务需要经常切换，这就涉及到串行，并行，并发的概念。 串行：一个任务执行完毕，另外一个任务才能执行。 并行：在单位时间内，多个任务同时执行。现在的多核CPU支持多个任务处理。 并发：在单位时间内，只能处理一个任务，其他任务获取到CPU时间片就会开始执行另外一个任务，操作系统本身会进行用户态和内核态的切换。 1.2进程的状态 ..
leetcode刷题app-suanfa:算法
07-01
leetcode刷题app 算法冲冲冲！！！！！！！适合后台人员的算法学习！！ 1. 后台学习方法 看刘宇波波的三个视频，看你想看的知识点就行，边看边做对应的题目 视频：三个视频的内容在下面的卡片里面！！链接： 提取码...
大厂算法和数据结构刷题班.zip
12-30
算法代码：我们提供了多种数据结构的实现代码，包括数组、链表、栈、队列、树、图等。这些代码不仅能帮助你理解数据结构的基本概念，而且能让你明白如何在实际情况中应用这些数据结构。 笔记：详细且系统的笔记，...
用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
leetcode中国-algorithm--pattern:算法--模式
06-29
基础算法篇 :cow_face: 算法思维 :lion: 心得体会 文章大部分是对题目的思路介绍，和一些问题的解析，有了思路还是需要自己手动写写的，所以每篇文章最后都有对应的练习题 刷完这些练习题，基本对数据结构和算法
【代码随想录】【算法训练营】【第35天】[134]加油站 [135]分发糖果 [860]柠檬水找零 [406]根据身高重建队列
weixin_54954007的博客
06-11 299
思路及算法思维，指路。题目来自。day 35，连休两天~
指针和数组
2301_77634163的博客
06-10 431
有3个指针，中间是一个数组arr，有个指针指向中间,其他两个指向两边，一个指向前面，一个人指向后面。虽然简化好，但是我们C语言要求是不允许这样写的,虽然大部分编译器是可以允许我这样写的。下面那个用数组名也是可以用的，因为他也表示一个地址，加1就会找后面那个元素的地址。我们C语言编译器中说指针允许往后比较大小，但不允许往前比面的指针比较大小。地址向后移，指针相比较，指针减减就是减去一个整数。同一指针相减的绝对值得到的是之间元素的个数。数组和指针的地址是一样的，说明是可以的。地址加地址，指针加指针没有意义。
力扣136. 只出现一次的数字
最新发布
LNsupermali的博客
06-15 381
力扣136. 只出现一次的数字
二叉树顺序结构——堆的结构与实现
qq3304968099的博客
06-10 878
二叉树顺序结构——堆的结构与源代码实现
如何快速提高算法题刷题能力
03-24
作为一个 AI，我建议您可以通过以下几个步骤来提高算法题刷题能力： 1.建立坚实的基础：学习算法和数据结构的基础知识，例如数组、链表、栈、队列、树、图等等。 2.刻意练习：刷题是提高算法能力的最好方法，可以通过 LeetCode、牛客网等平台进行练习。 3.多思考多总结：在做题的过程中，要多思考，多总结，不仅要知道如何解决问题，还要知道为什么这种方法是最优解。 4.参加比赛：参加算法比赛可以锻炼自己的思维能力和应变能力，例如 ACM、Google Code Jam 等。 希望这些建议能够帮助您提高算法题刷题能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

乌云暮年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值