数据结构与算法（Java实现）之【队列】

已于 2022-01-28 00:01:05 修改
阅读量138 收藏
点赞数
分类专栏： # 数构+算法+设计分析 文章标签： 数据结构 算法 java
于 2022-01-25 15:17:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46344594/article/details/122685896
版权

队列

在这里插入图片描述

1、场景

在这里插入图片描述

2、介绍

在这里插入图片描述

3、数组模拟队列

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4 代码实现

import java.util.Scanner;

/**
 * 数组模拟队列
 */
public class ArrayQueueDemo {
    public static void main(String[] args) {
        //测试一把
        //创建一个队列
        ArrayQueue queue = new ArrayQueue(3);
        char key = ' ';//接收用户输入
        Scanner scanner = new Scanner(System.in);//
        boolean loop = true;
        //输出一个菜单
        while(loop) {
            System.out.println("q(show): 显示队列");
            System.out.println("w(add): 添加数据到队列");
            System.out.println("e(get): 从队列取出数据");
            System.out.println("r(head): 查看队列头的数据");
            System.out.println("t(exit): 退出程序");
            key = scanner.next().charAt(0);//接收一个字符
            switch (key) {
                case 'q': //显示队列
                    queue.showQueue();
                    break;
                case 'w': //添加数据到队列
                    System.out.println("输入一个数");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'e': //取出数据  只能从头取
                    try {
                        int res = queue.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'r': //查看队列头的数据
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;

                case 't': //退出
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
                }
            }

    }
}

// 使用数组模拟队列-编写一个 ArrayQueue 类
class ArrayQueue{
    private int maxSize; // 表示数组的最大容量
    private int front; // 队列头
    private int rear; // 队列尾
    private int[] arr; // 该数据用于存放数据, 模拟队列

    // 创建队列的构造器
    public ArrayQueue(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = -1; // 指向队列头部，分析出front是指向队列头的前一个位置.
        rear = -1; // 指向队列尾，指向队列尾的数据(即就是队列最后一个数据)
    }


    // 判断队列是否满
    public boolean isFull() {
        return rear == maxSize - 1;
    }
    // 判断队列是否为空
    public boolean isEmpty() {
        return rear == front;
    }

    // 添加数据到队列
    public void addQueue(int n) {
        // 判断队列是否满
        if (isFull()) {
            System.out.println("队列满，不能加入数据~");
            return;
        }
        rear++; // 让rear 后移
        arr[rear] = n;
    }
    // 获取队列的数据, 出队列
    public int getQueue() {
        // 判断队列是否空
        if (isEmpty()) {
            // 通过抛出异常
            throw new RuntimeException("队列空，不能取数据");
        }
        front++; // front后移
        return arr[front];

    }
    // 显示队列的所有数据
    public void showQueue() {
        // 遍历
        if (isEmpty()) {
            System.out.println("队列空的，没有数据~~");
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d]=%d\n", i, arr[i]);
        }
    }
    // 显示队列的头数据， 注意不是取出数据
    public int headQueue() {
        // 判断
        if (isEmpty()) {
            throw new RuntimeException("队列空的，没有数据~~");
        }
        return arr[front + 1];
    }
}

注意点：
原来队列和下面的环形队列的区别
原来：rear =-1 front=-1
下面：rear =0 front=0
环形队列最后面还留了个空，为了配合公式：
当队列满时，条件是 (rear + 1) % maxSize == front【满】

5 优化： 环形队列

（1）介绍

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

（2）2个重要问题

下标计算问题

在这里插入图片描述

循环队列“空”与“满”的判定

在这里插入图片描述

形象的

在这里插入图片描述

Java代码实现

import java.util.Scanner;

/**
 * 优化
 * 环形队列
 */
public class CircleArrayQueueDemo {
    public static void main(String[] args) {

        //测试一把
        System.out.println("测试数组模拟环形队列的案例~~~");

        // 创建一个环形队列
        CircleArray queue = new CircleArray(4);
                                    //说明设置4, 其队列的有效数据最大是3
        char key = ' '; // 接收用户输入
        Scanner scanner = new Scanner(System.in);//
        boolean loop = true;
        // 输出一个菜单
        while (loop) {
            System.out.println("s(show): 显示队列");
            System.out.println("e(exit): 退出程序");
            System.out.println("a(add): 添加数据到队列");
            System.out.println("g(get): 从队列取出数据");
            System.out.println("h(head): 查看队列头的数据");
            key = scanner.next().charAt(0);// 接收一个字符
            switch (key) {
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("输出一个数");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g': // 取出数据
                    try {
                        int res = queue.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h': // 查看队列头的数据
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e': // 退出
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出~~");
    }

}


class CircleArray{
    private int maxSize;// 表示数组的最大容量
    //front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素
    //front 的初始值 = 0
    private int front;
    //rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
    //rear 的初始值 = 0
    private int rear; // 队列尾
    private int[] arr; // 该数组用于存放数据, 模拟队列

    public CircleArray(int arrMaxSize){
        maxSize = arrMaxSize;
        arr = new int[maxSize];
    }

    // 判断队列是否满
    public boolean isFull(){
        return (rear +1 ) % maxSize == front; //??没理解
    }

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

    // 添加数据到队列
    public void addQueue(int n){
        // 判断队列是否满
        if (isFull()) {
            System.out.println("队列满，不能加入数据~");
            return;
        }
        //直接将数据加入
        arr[rear] = n;
        //将 rear 后移, 这里必须考虑取模
        rear = (rear + 1) % maxSize;
    }

    // 获取队列的数据, 出队列
    public int getQueue() {
        // 判断队列是否空
        if (isEmpty()) {
            // 通过抛出异常
            throw new RuntimeException("队列空，不能取数据");
        }
        // 这里需要分析出 front是指向队列的第一个元素
        // 1. 先把 front 对应的值保留到一个临时变量
        // 2. 将 front 后移, 考虑取模
        // 3. 将临时保存的变量返回
        int value = arr[front];
        front = (front + 1) % maxSize;
        return value;

    }


    // 显示队列的所有数据
    public void showQueue() {
        // 遍历
        if (isEmpty()) {
            System.out.println("队列空的，没有数据~~");
            return;
        }
        // 思路：从front开始遍历，遍历多少个元素
        // 动脑筋
        for (int i = front; i < front + size() ; i++) {
            System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
        }
    }
    // 求出当前队列有效数据的个数
    public int size() {
        // rear = 2
        // front = 1
        // maxSize = 3
        return (rear + maxSize - front) % maxSize;
    }
    // 显示队列的头数据， 注意不是取出数据
    public int headQueue() {
        // 判断
        if (isEmpty()) {
            throw new RuntimeException("队列空的，没有数据~~");
        }
        return arr[front];
    }

}

6、链表模拟队列


public class LinklistQueue {
    Node front;//队头指针，指向队头节点
    Node rail;//队尾指针，指向队尾节点

    int size = 0;//记录队列长度


    //构造函数
    public LinklistQueue() {
        front = rail = null;
    }

    public boolean isEmpty() {
        return size == 0 ? true : false;
    }

    public void showQueue(){
        if (size != 0){
            while (front != null){
                System.out.println( front.getElement());
                front = front.next;
            }

        }
    }

    //添加元素
    public boolean addQueue(String ele) {
        if (size == 0) {
            front = new Node(null, ele);
            rail = front;
            size++;
            return true;
        }
        Node s = new Node(null, ele);
        //这块有个主意的地方，一旦rail设置了next属性，因为front节点与rail节点指向了同一个node节点，持有同一个结点的一个引用，因此front节点next属性也被填充
        rail.setNext(s);
        rail = s;
        size++;
        return true;
    }


    /**
     * 删除元素,出队列
     * @return
     */
    public boolean deleteQueue() {
        if (isEmpty()) {
            System.out.println("当前队列为空");
            return false;
        }

        front = front.next;
        size--;
        return true;

    }


    public static void main(String[] args) {
        LinklistQueue queue = new LinklistQueue();

        queue.addQueue("1");
        queue.addQueue("2");
        queue.addQueue("3");
        queue.deleteQueue();
        queue.showQueue();
        System.out.println();
        System.out.println("长度="+queue.size);

    }


}

/**
 * 节点类
 */
class Node {

    Node next;
    String element;

    public Node(Node next, String element) {
        this.next = next;
        this.element = element;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    public String getElement() {
        return element;
    }

    public void setElement(String element) {
        this.element = element;
    }

}

7、队列的应用举例

在这里插入图片描述

打印杨辉三角问题

在这里插入图片描述

队列 杨辉三角

/**
 * @create: 2022-01-27 23:56
 * PS ==>  队列  杨辉三角
 */

public class yh_ {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt(); // 输入一个正整数；
        yanghui(n);
    }

    public static void yanghui(int n) {
        LinkedList<QueueNode> nodes = new LinkedList<QueueNode>();  //队列
        nodes.add(new QueueNode(1));
        nodes.add(new QueueNode(1));
        nodes.add(new QueueNode(1));
        for (int i = 1; i <= n; i++) {
            int j = i;
            while (j > 0) {
                if (j == 1 && i >= 2) {
                    System.out.print(nodes.removeFirst().getId());
                    nodes.add(new QueueNode(1));
                    j--;
                } else {
                    int a = nodes.removeFirst().getId();
                    System.out.print(a + " ");
                    if (i >= 2) {
                        if (j == i) {
                            nodes.add(new QueueNode(1));
                        }
                        nodes.add(new QueueNode(a + nodes.getFirst().getId()));
                    }
                    j--;
                    /*
                     * if (j == 0 && i >= 2) { nodes.add(new QueueNode(1)); }
                     */
                }
            }
            System.out.println();
        }

    }

}

class QueueNode { // 队列中的结点
    int id;

    public QueueNode(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

}

在这里插入图片描述

好看杨辉三角

/**
 * @create: 2022-01-27 23:58
 * PS ==> 好看杨辉三角
 */

public class yh_1 {
    public static void main(String[] args) {
        System.out.println("输出行数：");
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();

        int arr[][] = getTri(n);
        printTri(arr);

    }


    public static int[][] getTri(int n) {
        int[][] arr = new int[n][n];

        for (int i = 0; i < n; i++) {
            arr[i][0] = arr[i][i] = 1;
        }
        for (int i = 2; i < arr.length; i++) {
            for (int j = 1; j < i; j++) {
                arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
            }
        }
        return arr;
    }

    public static void printTri(int[][] arr) {
        for (int i = 0; i < arr.length; i++) {
            //输出杨辉三角数字前的空格
            for(int j = 0;j<arr.length-1-i;j++) {
                System.out.print("   ");
            }
            for(int j = 0;j<=i;j++) {
                //打印空格填补空位
                System.out.print("   ");
                System.out.printf("%-3d",arr[i][j]);
            }
            System.out.println();
        }
    }

}

在这里插入图片描述

8、小姐

  • 定义
    限定只能在表的一端进行插入和，在表的另一端进行删除（头删尾插）
  • 逻辑结构
    与线性表相同，仍是一对一关系
  • 存储结构
    顺序队或链队，以循环顺序队更常见
  • 运算规则
    只能在队首和队尾运算，且访问节点时依照先进先出（FIFO）原则
  • 实现方式
    关键是掌握入队和出队操作，具体依顺序队还是链队不同
高高飞起的勇敢麦当
关注
专栏目录
Java队列
zcker
05-02 300
Java队列 队列的两端都"开口"，要求数据只能从一端进，从另一端出，且数据的进出要遵循 “先进先出” 的原则，即最先进队列的数据元素，同样要最先出队列。 其中，对于队列中的某一数组来说具有font和back还有个数currentsize，操作enquene是在rear插入一个元素，dequene是删除并返回在font的一个元素，不浪费空间的方法即为循环队列 接口实现： /* *项目名: Ja...
java队列
04-19
NULL 博文链接：https://hoochiang.iteye.com/blog/1858476
队列
Hern（宋兆恒）
09-23 268
简介 队列是一个有序列表，可以用数组或是链表来实现。遵循先进先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 数组模拟队列 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front及 rear分别记录队列前后端的下标，front 会随着数据输...
java数据结构与算法.pdf
01-04
Java作为广泛应用的编程语言，其在实现数据结构和算法时有着丰富的库支持和优秀的可读性。下面将对标题和描述中提到的一些关键知识点进行详细解释。 1. **数据结构**： - **稀疏数组**：当大量数据中大部分为零或...
数据结构与算法代码详解JAVA版
08-26
本资源"数据结构与算法代码详解JAVA版"聚焦于使用Java语言来理解和实现这些核心概念。 首先，数据结构是组织和存储数据的方式，它为高效地执行各种操作提供了便利。常见的数据结构包括数组、链表、栈、队列、树（如...
#数据结构与算法java实现 #包括排序，线性表，树，图，散列等基础数据结构.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
【JAVA】队列
最新发布
m0_73427585的博客
04-28 3264
同步：发出一个请求即为一个同步调用。（发出请求会得到响应，没有返回响应就会死等结果，需要注意在等待的过程中现成是激活的状态并没有暂停。异步：发出一个请求等待结果过程中，可以继续发出后续的请求。（这个结果会通过callback、状态或者通知的方式来告知调用方结果。异步经历两个步骤：1.调用方发起请求，2.服务提供方对请求的结果进行返回。单看一个请求的发起是同步操作，但是异步主要体现在只要有结果都会通过callback、状态或者通知的方式告知，因此不会存在同步的死等结果。
java中的队列
yaoyaobird11的博客
08-23 1656
一、队列的定义 我们都知道队列(Queue)是一种先进先出(FIFO)的数据结构，Java中定义了java.util.Queue接口用来表示队列。Java中的Queue与List、Set属于同一个级别接口，它们都是继承于Collection接口。 Java中还定义了一种双端队列java.util.Deque，我们常用的LinkedList就是实现了Deque接口。 下面我们看一下类的定义： Queue & Deque public interface Queue<E> extends C
Java中的队列
weixin_46356448的博客
01-07 1449
将列表作为队列使用，add()在队尾添加元素，remove(0)删除队头，但会导致后续大量元素的移动，对于有许多增删操作的情况性能较差，适用于查找和修改需求大的情况。实现了Queue接口、Deque接口、List接口，offer()在队尾添加元素，poll()删除队头并返回，使用指针链接元素，对增删操作有较好的性能，无需移动元素。有界阻塞队列，有固定容量，创建时需要指定队列的大小，底层基于数组实现，在增删元素时可能会阻塞线程，直到满足特定的条件。阻塞添加和阻塞删除方法。
python删除列表中元素_python如何删除列表一个元素
weixin_39895481的博客
11-20 510
下面举例说明几种python删除列表中元素的方法方法一用remove("")方法删除指定元素，没有该元素时报错>>> number=[1,3,2,0]>>> number.remove(1)#删除指定元素1，这里是int类型因此不需要引号>>> print(number)[3, 2, 0]方法二利用del[索引数] 函数删除指定索引数的元素>>> number=[1,3,2,0]>>> del n...
数据结构 队列 数组实现
qq_45858803的博客
01-09 69
文章目录了解队列class ArrayQueueclass TestApp 了解队列 class ArrayQueue public class ArrayQueue { //用数组来实现队列 private int[] array; //通过maxSize来指定队列的大小 //通过maxSize我们可以自由实现数组大小的控制 private int maxSize; //队首指针 private int frontPoint; //队尾指针
Java 队列
sinat_37138973的博客
03-13 225
阻塞队列 含义 举例 DelayQueue 延迟队列 非阻塞队列 非阻塞算法 举例 使用场景 队列非常适合于生产者/消费者这种业务场景，像rabbitMq，activeMq都是对queue的一个封装的中间件。 阻塞队列 含义 阻塞队列（Blocking queue）提供了可阻塞的put和take方法，它们与可定时的offer和poll是等价的。如果Qu...
Java-队列
花落因为花开过的博客
02-10 1235
队列 队列只允许一端插入元素，从另一端进行删除元素的特殊线性表。队列具有先进先出的特点。 入队：进入插入操作，这一端称为队尾。 出队：进行删除操作，这一端称为对头
java 队列
New_Bird
04-15 568
队列 解释：类似于现实生活中的排队活动，银行叫号码等，其是一个有序的列表，可以用数组或者链表来完成，遵循先入先出的原则 放进入后： 取出： 取出时从头取出，因为头部是先放进去的，先入先出 这是个单向队列：有个问题是用完的空间会浪费掉，不能循环利用 import java.util.Scanner; //单向队列 public class ArrayQueue { public static...
JAVA队列
蒙面侠的博客
03-08 121
队列的定义 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的 后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为 队尾，进行删除操作的端称为队头。 队列的基本操作 JAVA中的LinkedList提供了方法以支持队列的行为，并且实现了Queue的接口 public class Queuedemo { public static void main(String[] args) { Queue<I
Java实现经典数据结构与算法详解
资源摘要信息: "本资源提供了在Java语言环境下实现常用数据结构及算法的详细教程和代码示例，覆盖了链表、栈、队列、树、堆、图等基础数据结构，以及排序等经典基础算法。适合于希望加深对数据结构与算法理解的Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

高高飞起的勇敢麦当

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

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

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

打赏作者

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

抵扣说明：

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

余额充值