“队列” 无罪，只是太美（Java篇）

本篇会加入个人的所谓‘鱼式疯言’

❤️❤️❤️鱼式疯言:❤️❤️❤️此疯言非彼疯言
而是理解过并总结出来通俗易懂的大白话,
小编会尽可能的在每个概念后插入鱼式疯言,帮助大家理解的.
🤭🤭🤭可能说的不是那么严谨.但小编初心是能让更多人能接受我们这个概念 ！！！

前言

在上一篇文章中我们讲解了可爱又有意思的 栈 的学习 ， 而在这篇文章中小编主要讲解 栈 的 “双胞胎兄弟” —————— 队列

小编在这里先留三个问题哈

什么是 队列 ？

队列 的特点有什么呢 ？

今天讲的 队列 和 栈 有我们异同呢 ？

目录

1. 队列的初识
2. Queue 类
3. 队列的实现

一. 队列的初识

1. 队列的简介

队列：只允许在 一端进行插入数据操作，在另一端进行删除数据 操作的特殊线性表，队列具有先进先出FIFO(First In First Out)

入队列：进行插入操作的一端称为队尾（Tail/Rear）

出队列：进行删除操作的一端称为 队头（Head/Front）

二.Queue 类

在Java中， 我们的 队列 就是Java中的 Queue ， 而Queue 是个接口，底层是通过 链表 实现的。

主要核心还是先入队的先出队，先入先出

下面来具体使用一下我们 Queue 类吧 💖 💖 💖

1. 入队列

class Test2 {
    public static void main(String[] args) {
        Queue<Integer> q= new LinkedList<>();
        q.offer(1);
        q.offer(2);
        q.offer(3);
        q.offer(4);
    }
}

从中我们看到了先入的进入 队头 ，后入的进入 队尾

2. 出队列

class Test2 {
    public static void main(String[] args) {
        Queue<Integer> q= new LinkedList<>();
        q.offer(1);
        q.offer(2);
        q.offer(3);
        q.offer(4);

        System.out.println("=========入队列=========");
        System.out.println(q.poll());
        System.out.println(q.poll());
        System.out.println(q.poll());
        System.out.println(q.poll());
    }
}

我们看到了 对头 数据先出栈， 队尾 数据后出栈

鱼式疯言

故队列的特点是：

先入先出，后入后出

3. 查队列

class Test2 {
    public static void main(String[] args) {
        Queue<Integer> q= new LinkedList<>();
        q.offer(1);
        q.offer(2);
        q.offer(3);
        q.offer(4);

        System.out.println("=========出队列=========");
        System.out.println(q.poll());  // 1
        System.out.println(q.poll());  // 2


        System.out.println("=========获取对头元素========");
        System.out.println(q.peek());  // 3
        System.out.println(q.peek());  // 3
    }
}

这里的 查队列 指的是 查找出我们对头的 第一个数据

故当我们删除掉先前对头的 1 ， 2 时，我们的对头的数据就变成了 3，所以显示 3

4. 获取队列大小和队列是否为空

class Test2 {
    public static void main(String[] args) {
        Queue<Integer> q= new LinkedList<>();
        q.offer(1);
        q.offer(2);
        q.offer(3);
        q.offer(4);

        System.out.println("=========出队列=========");
        System.out.println(q.poll());  // 1
        System.out.println(q.poll());  // 2


        System.out.println("=========获取对头元素========");
        System.out.println(q.peek());  // 3
        System.out.println(q.peek());  // 3


        System.out.println("======获取队列大小=======");
        System.out.println(q.size());

        System.out.println("=======判断队列是否为空=======");
        if (q.isEmpty()) {
            System.out.println("队列为空！");
        } else {
            System.out.println("队列不为空！");
        }
    }
}

是的，我们的队列是有着和 栈 一样的 == size（） == 和 ==empty（）==一样的方法

但聪明的小爱就有疑惑了，居然使用方法是一样的，那么我们的实现这个方法的 底层 是不是一样的呢 ？ ？ ？

这个问题问的好，下面就让我们动手实践去试试呗，看看我们的方法在实现的原理上是否是一样的 ！！ ！

三. 队列的实现

和 栈 一样，我们的队列既可以选择顺序表也可以选择链表 ,但这次就不一样了，这次小编的建议是选择 链表

具体为啥，我们先看看框架吧 💥 💥 💥

1. 建立框架

public class MyQueue implements IQueue {

    List<Integer> queue;

    public MyQueue() {
        queue= new LinkedList<>();
    }
}

址所以用我们的链表来实现就是因为，链表对于删除头节点的那个数据的时间复杂度是 O(1)

而 顺序表 删除头数据的，由于要扭动数据，所以时间复杂度达到了 O(N)

故我们选择

 queue= new LinkedList<>();

这样 双向链表为框架进行实现

2. 入队列

@Override
public boolean offer(int val) {


    queue.add(val);

    return true;
}

这里我们入队列用到了 双向链表 的的 尾插 功能

具体链表的功能可以参考

单链表详解链接

3. 出队列

    @Override
    public int remove() {
        return queue.remove(0);
    }

这里我们 出队列 用到了 双向链表 的 头删 功能

查队列

   @Override
    public int peek() {
        return queue.get(0);
    }

这里利用到 链表 的获取第一个元素的功能

4. 获取队列大小和是否为空

@Override
public int size() {
    return queue.size();
}


public boolean isEmpty() {
    return queue.isEmpty();
}

从中我们利用 链表的 size() 和 isEmpty（） 两个方法爱实现我们的队列

鱼式疯言

单链表也是可以实现我们的队列的

单链表详解链接

如果小伙伴们想熟悉 双向链表 的话，请移步小编的下一篇文章：== 双向链表== 哦 💖 💖 💖

总结

• 队列的初识 ： 我们初识了队列并熟悉了它的特点
• Queue 类：明白了这个类下学会了使用我们队列的主要功能
• 队列的实现： 在双向链表的搭配下，我们轻松的完成了队列的实现

可谓收获颇丰啊 💖 💖 💖 💖

如果觉得小编写的还不错的咱可支持 三连 下 (定有回访哦) , 不妥当的咱请评论区 指正

希望我的文章能给各位宝子们带来哪怕一点点的收获就是 小编创作 的最大 动力 💖 💖 💖