队列（数据结构系列8）

最新推荐文章于 2024-09-23 22:27:40 发布
最新推荐文章于 2024-09-23 22:27:40 发布
阅读量446 收藏
点赞数
分类专栏： 数据结构 Java 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61599986/article/details/129648245
版权

目录

前言：

1.队列的概念

2.队列的使用

3.队列的模拟实现

3.1采用单链表来实现队列

3.2采用双向链表来实现

4.循环队列

5.双端队列

6.用队列来实现栈

7.用栈来实现队列

结束语：

前言：

上一次小编与大家分享了栈的使用方法，这节中我们来学习一下队列，它又和栈有何区别，两者之间我们又有哪些可以相互转化呢？快来跟着小编一起来学习吧！！！

1.队列的概念

只允许在一端进行插入数据操作，在另一端进行数据删除操作的特殊线性表，队列具有先进先出的特性，入队列：进行插入操作的一端的称之为队尾（rear/tail），出队列：进行删除操作的一端称之为对头（head/front）。

 

2.队列的使用

在java中，Queue是一个接口，底层是通过链表实现的。

代码如下所示：

package 队列的使用;

import java.util.LinkedList;
import java.util.Queue;

public class Test {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        //入队列
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        queue.offer(4);
        queue.offer(5);
        queue.offer(6);
        //出队列
        System.out.println(queue.poll());//1
        System.out.println(queue.poll());//2
        //查看队首元素
        System.out.println(queue.peek());//3
        System.out.println(queue.peek());//3
        //计算队列的大小
        System.out.println(queue.size());//4
        //检测队列是否为空
        System.out.println(queue.isEmpty());//false
    }
}

结果如下所示：

3.队列的模拟实现

3.1采用单链表来实现队列


代码如下所示：

package 采用单链表来实现队列;


public class MyQueue1 {
    class ListNode{
        public ListNode next;//下一个结点
        public int val;//结点的值
        public ListNode(int val) {
            this.val = val;
        }
    }
    ListNode first;
    ListNode last;
    int size = 0;

    //入队列
    public void offer(int x) {
        //创建一个结点
        ListNode node = new ListNode(x);
        //以尾插法进行入队
        if (first == null) {
            first = node;
            last = node;
        } else {
            last.next = node;
            last = node;
        }
        size++;
    }

    //出队列
    public int poll() {
        //判断队列是否为空
        if (first == null){
            return -1;
        }
        int value = first.val;
        ListNode cur = first;
        first = first.next;
        cur.next = null;
        size--;
        return value;
    }

    //查看队首元素
    public int peek() {
        //判断是否为空
        if (first == null) {
            return -1;
        }
        return first.val;
    }

    //计算大小
    public int size() {
        return size;
    }

    //判断队列是否为空
    public boolean isEmpty() {
        return first == null;
    }
}

测试类代码：
 

package 采用单链表来实现队列;

public class Test {
    public static void main(String[] args) {
        MyQueue1 myQueue1 = new MyQueue1();
        //入队列
        myQueue1.offer(1);
        myQueue1.offer(2);
        myQueue1.offer(3);
        myQueue1.offer(4);
        myQueue1.offer(5);
        myQueue1.offer(6);
        //出队列
        System.out.println(myQueue1.poll());//1
        System.out.println(myQueue1.poll());//2
        System.out.println(myQueue1.poll());//3
        //查看队首元素
        System.out.println(myQueue1.peek());//4
        System.out.println(myQueue1.peek());//4
        //计算大小
        System.out.println(myQueue1.size());//3
        //判断是否为空
        System.out.println(myQueue1.isEmpty());//false
    }
}

结果如下所示：

 

3.2采用双向链表来实现


代码如下所示：

package 采用双向链表来实现队列;


public class MyQueue {
    //内置类来定义一个双向链表
    class ListNode{
        ListNode next;//下一个结点
        ListNode prev;//前驱结点
        public int val;//结点的值
        public ListNode(int val) {
            this.val = val;
        }
    }

    ListNode first;//队首
    ListNode last;//队尾
    int size = 0;

    //入队列
    public void offer(int x) {
        //创建一个新的结点
        ListNode node  = new ListNode(x);
        //向队尾插入这个结点
        if (first == null) {
            first = node;
            //last = node;
        }else {
            last.next = node;
            node.prev = last;
            //last = node;
        }
        last = node;
        size++;
    }

    //出队列
    public int poll() {
        int value = 0;
        //出链表的头结点
        if (first == null) {
            return -1;
        } else if (first == last){
            value = first.val;
            first = null;
            last = null;
        } else {
            value = first.val;//保存一下头结点的值
            first = first.next;//将头结点指向移向下一个结点
            first.prev.next = null;//将现在头结点的前驱的next域置为空
            first.prev = null;//将现在头结点的前驱置为空
        }
        size--;
        return value;
    }

    //查看队首元素
    public int peek() {
        if (first == null) {
            return -1;
        }
        return first.val;
    }

    //计算队列中元素的个数
    public int size() {
        return size;
    }

    //判断队列是否为空
    public boolean isEmpty() {
        return first == null;
    }
}

测试类代码：
 

package 采用双向链表来实现队列;

public class Test {
    public static void main(String[] args) {
        MyQueue myQueue = new MyQueue();
        //如队列
        myQueue.offer(1);
        myQueue.offer(2);
        myQueue.offer(3);
        myQueue.offer(4);
        myQueue.offer(5);
        myQueue.offer(6);
        //出队列
        System.out.println(myQueue.poll());//1
        System.out.println(myQueue.poll());//2
        System.out.println(myQueue.poll());//3
        //查看队首元素
        System.out.println(myQueue.peek());//4
        System.out.println(myQueue.peek());//4
        //计算队列元素的个数
        System.out.println(myQueue.size());//3
        //判断队列是否为空
        System.out.println(myQueue.isEmpty());//false
    }
}

结果如下所示：

4.循环队列

何为循环队列呢？下面我们直接用图来解释一下什么是循环队列。

我们一般会采用数组来实现它，那么在放到最后的一个位置的时候我们如果出了前面的元素，此时在我们看来这个循环队列是不满的，但是我们又应该怎么将队尾元素来循环的指向第一个元素呢？以及我们又是怎么来区分空间是否已经满了呢？

 一、解决怎么循环的问题

当出现下面的情况下我们发现队列中并没有满，那么我们应该怎么将rear从7下标移动到0下标呢？

其实我们只要在给rear赋值的时候赋值为：rear = （rear + 1）% length即可，同理如果是front也是一样的处理方式。  

二、怎么判断是否已经满了？

  1. 通过添加size属性记录
  2. 保留一个位置
  3. 使用标记

下面我们就采用保留一个位置为例来实现一个循环的队列。

代码如下所示：

package 循环队列;

class MyCircularQueue {

    public int[] elem;
    private int front;//表示队列的尾
    private int rear;//表示队列的尾
    public MyCircularQueue(int k) {
        this.elem = new int[k + 1];
    }
    //入队列
    public boolean enQueue(int value) {
        //1.检查队列是否为满
        if (isFull()) {
            return false;
        }
        elem[rear] = value;
        rear = (rear + 1) % elem.length;
        return true;
    }
    //出队列
    public boolean deQueue() {
        if (isEmpty()) {
            return false;
        }
        front = (front + 1) % elem.length;
        return true;
    }
    //得到队头元素
    public int Front() {
        if (isEmpty()) {
            return -1;
        }
        return elem[front];
    }
    //得到队尾元素
    public int Rear() {
        if (isEmpty()) {
            return -1;
        }
        int index = (rear == 0) ? elem.length - 1 : rear - 1;
        return elem[index];
    }
    
    public boolean isEmpty() {
        return front == rear;
    }
    
    public boolean isFull() {
        if ((rear + 1) % elem.length == front) {
            return true;
        }
        return false;
    }
}


结果如下所示：

 

5.双端队列

双端队里就是指允许两端都可以进行入队列和出队列操作的队列，deque是"double ended queue"的简称，那就说明元素可以从队列出队和入队，也可以从队尾出队和入队。

在实际开发过程中，使用deque接口是比较多的，栈和队列均可以使用该接口。

package 双端队列;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;

//两边都可以出和进
public class Test {
    public static void main(String[] args) {
        Deque<Integer> deque = new LinkedList<>();
        Deque<Integer> deque1 = new ArrayDeque<>();
    }
}

6.用队列来实现栈

代码如下所示：

package 队列来实现栈;

import java.util.LinkedList;
import java.util.Queue;

public class MyStack {
    public Queue<Integer> queue1;
    public Queue<Integer> queue2;
    public MyStack() {
        //初始化
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }
    //入栈
    public void push(int x) {
        if (!queue1.isEmpty()) {
            queue1.offer(x);
        } else if (!queue2.isEmpty()) {
            queue2.offer(x);
        }else {
            queue1.offer(x);
        }
    }
    //出栈
    public int pop(int x) {
        if (empty()) {
            return -1;//两个队列都为空
        }
        if (!queue1.isEmpty()) {
            int size = queue1.size();
            while (size > 1) {
                queue2.offer(queue1.poll());
            }
            return queue1.poll();
        }else {
            int size = queue2.size();
            while (size > 1) {
                queue1.offer(queue2.poll());
            }
            return queue2.poll();
        }
    }
    //查看栈首元素
    public int top() {
        if (empty()) {
            return -1;//两个队列都为空
        }
        if (!queue1.isEmpty()) {
            int val = -1;
            int size = queue1.size();
            for (int i = 0; i < size; i++) {
                val = queue1.poll();
                queue2.offer(val);
            }
            return val;
        }else {
            int val = -1;
            int size = queue2.size();
            for (int i = 0; i < size; i++) {
                val = queue2.poll();
                queue1.offer(val);
            }
            return val;
        }
    }

    //判断是否为空
    public boolean empty() {
        return queue1.isEmpty() && queue2.isEmpty();
    }
}

7.用栈来实现队列

package 栈实现队列;

//用两个栈来实现队列
import java.util.Stack;

public class MyQueue {
    private Stack<Integer> stack1;
    private Stack<Integer> stack2;
    public MyQueue() {
        stack1 = new Stack<>();
        stack2 = new Stack<>();
    }
    //入队列
    public void offer(int x) {
        stack1.push(x);
    }
    //出队列
    public int poll() {
        if (empty()) {
            return -1;
        }
        if (stack2.empty()) {
            while (!stack1.empty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
    //查看队列顶端元素
    public int peek() {
        if (empty()) {
            return -1;
        }
        if (stack2.empty()) {
            while (!stack1.empty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.peek();
    }
    //看两个栈是否都为空
    public boolean empty() {
        return stack1.empty() && stack2.empty();
    }
}

结束语：

这节中小编主要与大家分享了队列的使用方法、循环队列、双端队列、用栈来实现队列以及用队列来实现栈。希望对大家有所帮助，想要学习的同学记得关注小编和小编一起学习吧！如果文章中有任何错误也欢迎各位大佬及时为小编指点迷津（在此小编先谢过各位大佬啦！）

数据结构中循环队列的代码
05-16
### 数据结构中循环队列的代码解析 #### 一、循环队列简介 循环队列是一种特殊的队列，它的特点是将存储空间想象成一个首尾相接的圆环，这样可以使队列在有限的空间内更好地利用内存。在普通队列中，当队头元素出...
数据结构基础系列(3)：栈和队列
06-08
系列课程包含11个部分，本课为第3部分栈和队列，介绍在系统软件和应用软件开发中大有用途的两种特殊线性表&mdash;&mdash;栈和队列的构组成、存储结构的选择，以及基本运算的实现，通过相关的应用案例介绍了这些数据结构的应用...
栈的概念及其基本操作--详细（C++）
smart_jackli的博客
11-06 1万+
栈的概念即基本操作，详细解读
数据结构——队列
cainiao的博客
04-16 1405
首先，什么是队列呢。队列和栈相似（都是一种操作受限的线性表）他的限制主要表现在只允许在表的一端进行插入操作，而在表的另一端进行删除操作。 队列基本知识 队列的顺序存储结构以及环形队列 数组模拟实现队列的基本操作 链表实现队列 C++ 中的STL实现队列 队列的基本知识 队列一般分为两端： 1.队头（队首）：进行删除元素操作的一端（这个操作也叫作出队/离队） 2.队尾：进行插入新元素的一端（这个操作叫做入队/进队）。 因此我们可以通过队列两端的性质发现队列其实是下图的一个线性表 &n
C++栈的基本操作
qq_43603719的博客
10-11 1202
栈的基本操作 头文件： #include<stack> 基本函数： s.push(item); //将item压入栈顶 s.pop(); //删除栈顶的元素，但不会返回 s.top(); //返回栈顶的元素，但不会删除 s.size(); //返回栈中元素的个数 s.empty(); //检查栈是否为空，如果为空返回true，否则返回false 用法： #include<iostream> #include<stack> using namespa
栈的基本操作(c++题解)
hb_zhyu的博客
01-23 470
我们可以把栈比喻成一个箱子，只能在箱子的开口处放入和取出物体，而且是后放入的物体，会被先取出来。第 1 行一个整数 n,表示有 条关于n 的操作s，在进行任何操作之前， s是空的。对于 empty 操作，如果栈是空，则输出 empty，否则输出 not empty。对于 top 操作，输出一个整数，如果这个操作失败，则输出单词 error。栈：插入元素和删除元素只能在线性表的一端进行，所以遵循“先进后出。对于 pop 操作，如果这个操作失败，则输出单词 error。
数据结构 -- 栈的基本操作（入栈、出栈、取栈顶元素）
weixin_53461714的博客
10-04 9622
栈的基本操作 初始化栈： #define MAXSIZE 5 typedef struct { int *top; int *base; int stacksize; }SqStack; void CreateStack(SqStack &S) { S.base=new int[MAXSIZE]; if(S.base==NULL){ cout<<"分配内存失败！"; return ; } S.
数据结构：八种数据结构大全
热门推荐
緑水長流*z
07-29 21万+
数据结构 1.1 数据结构概述 数据结构是计算机存储、组织数据的方式；通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构的优良将直接影响着我们程序的性能；常用的数据结构有：数组（Array）、栈（Stack）、队列（Queue）、链表（Linked List）、树（Tree）、图（Graph）、堆（Heap）、散列表（Hash）等； 1.2 数据结构的分类 1.2.1 排列方式 1）集合 集合：数据结构中的元素之间除了“同属一个集合” 的相互关系外，别无其他关系； 2）线性结构 线性
数据结构之队列
jiaomubai的博客
02-05 3623
什么是队列 队列（queue）是一种线性数据结构。与同为线性数据结构的栈不同的是队列中的元素遵循的是先进先出（First In First Out）的规则，和在现实中排队一样，讲究的是先来后到的原则。队列出口端叫做队头（front），队列的入口端叫做队尾（rear）。 与栈类似，队列这种线性数据结构既可以用数组来实现，也可以用链表来实现。用数组来实现时，我们可以自行规定队尾的位置，比如说规定最后一个元素的下一个位置为队尾，或者规定最后一个元素所在的位置为队尾，这两种都行，毕竟是自己实现的。本文规定最后一
【数据结构】栈和队列
小羊的博客
07-12 2582
栈超超超详解
【数据结构之队列系列】队列详解
胡坚涛的博客
01-11 3961
前面我们学习了一种数据结构：栈，栈是一种只允许在一端尽进行插入删除的数据结构，而今天我们将学习另一种数据结构：队列，队列是一种支持在一端进行插入，在另一端进行删除的数据结构。
数据结构--队列实验报告.docx
03-24
数据结构中的队列是一种线性数据结构，它遵循“先进先出”（FIFO, First In First Out）的原则。在本实验报告中，主要探讨了三种类型的队列：链队列、顺序队列和循环队列。 1. 链队列： 链队列是由一系列节点组成...
数据结构-队列的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 队列的部分实现代码，详细介绍参考数据结构--队列的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
数据结构 队列实现 数据结构 队列实现
07-07
### 数据结构：队列实现详解 #### 一、队列概念与特性 在计算机科学领域，**队列**是一种常见的线性数据结构，遵循先进先出（First In First Out, FIFO）的原则。也就是说，最早添加到队列中的元素将是最先被移除的...
数据结构2——单链表
最新发布
weixin_73629886的博客
09-23 1136
了解了顺序表的不足，下面我们就来学习一下链表，看一看链表能不能解决顺序表的不足。
数据结构：二叉树（2）
2303_78940834的博客
09-21 1276
普通的树的实用价值比较小，将树更一步特殊化成二叉树，将获得更多的特殊性质。例如搜索二叉树，红黑树等。这篇博文主要介绍二叉树的基础知识，进阶版高级二叉树，后续会持续更新。
【数据结构取经之路】图解红黑树
bit_pan的博客
09-20 858
AVL-tree之外，另一个颇具历史且被广泛使用的平衡二叉搜索树是红黑树(RB-tree)，这名字听起来除了很抽象外，还颇具大哥味哈，会不会很难？客观地说，难度是有的，下面我们细细道来。//结点的颜色//红黑树结点的定义//结点的左孩子//结点的右孩子//结点的父节点//结点的颜色T _data;//结点的数据域{}以上就是红黑树节点定义，但有两个问题：为什么需要指向父节点的指针？为什么要将结点的默认颜色设置成黑色？先来回答第一个问题，在旋转时需要访问父节点，所以引入了指向父节点的指针。
代码随想录算法训练营 | 二叉树理论基础
jiabao0520的博客
09-22 537
训练营：二叉树理论基础
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

努力敲代码的小白✧٩(ˊωˋ*)و✧

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

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

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

打赏作者

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

抵扣说明：

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

余额充值