数据结构与算法——队列

于 2022-04-18 19:42:29 发布
阅读量312 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ghoul___/article/details/124257519
版权

队列

队列介绍

  • 队列是一个有序列表，可以用数组或是链表来实现。

  • 遵循先入先出的原则。即:先存入队列的数据，要先取出。后存入的要后取出

  • 示意图:(使用数组模拟队列示意图)

在这里插入图片描述

上图的清晰图 rear待表队列的尾部 front代表数据的头部 存入数据时 front不变 rear变化 存数据时 rear位置不变 front 的位置在变化

数组模拟队列思路

rear == maxSize-1 为满 front指向队列头部的头一个位置 rear指向队列尾部的具体位置

在这里插入图片描述

队列数组代码实现

package com.iswhl.queue;

import java.util.Scanner;

public class ArrayQueueDemo {
    public static void main(String[] args) {
        //测试
        ArrayQueue arrayQueue = new ArrayQueue(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':
                    try {
                        arrayQueue.showQueue();
                    } catch (Exception e) {
                        System.out.println("当前队列为空，无法取出数据");
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                case 'a':
                    try {
                        System.out.println("请输入您要添加的数据：");
                        int value = scanner.nextInt();
                        arrayQueue.addQueue(value);
                    } catch (Exception e) {
                        System.out.println("队列已满，无法添加数据！");
                    }
                    break;
                case 'g':
                    try {
                        int queue = arrayQueue.getQueue();
                        System.out.println("取出的数据为："+queue);
                    } catch (Exception e) {
                        System.out.println("当前队列为空，无法取出数据");
                    }
                    break;
                case 'h':
                    try {
                        int i = arrayQueue.headQueue();
                        System.out.println("取出的数据为："+i);
                    } catch (Exception e) {
                        System.out.println("当前队列为空，无法取出数据");
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出~");
    }

}
//数组模拟队列
class ArrayQueue{
    private int maxSize;//数组的最大长度
    private int fornt;//数组的头部
    private int rear;//数组的尾部
    private int[] arr;//定于数组的名称

    //编写模拟队列的构造器，用于初始化队列
    public ArrayQueue(int arrMaxSize){
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        fornt = -1;//指向队列的头部，分析出fornt开始时指向队列头[0]的前一个位置[-1]
        rear = -1;//指向队列尾部，即队列的最后一个数据
    }
    //判断队列是否满了
    public boolean isFull(){
        return rear == maxSize-1;
    }
    //判断队列是否为空
    public boolean isEmpty(){
        return rear == fornt;
    }
    //给队列中添加数据
    public void addQueue(int n){
        if (isFull()){
            throw new RuntimeException("队列已满，不能添加数据");
        }
        rear++;
        arr[rear] = n;
    }
    //从队列中拿出数据
    public int getQueue(){
        if (isEmpty()){
            throw new RuntimeException("当前队列为空，无法取出数据");
        }
        fornt++;
        return arr[fornt];
    }
    //读取队列中的数据
    public void showQueue(){
        if (isEmpty()){
            throw new RuntimeException("当前队列为空，无法取出数据");
        }
        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[fornt+1];//因为fornt开始时指向队列头[0]的前一个位置[-1]，所以在取出队列头的值时需要将队列头的值加1
    }
}

运行结果

"D:\whl151885\IdEA\IntelliJ IDEA 2020.1.2\jbr\bin\java.exe" "-javaagent:D:\whl151885\IdEA\IntelliJ IDEA 2020.1.2\lib\idea_rt.jar=58823:D:\whl151885\IdEA\IntelliJ IDEA 2020.1.2\bin" -Dfile.encoding=UTF-8 -classpath E:\数据结构与算法\DataStructures\out\production\DataStructures com.iswhl.queue.ArrayQueueDemo
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
当前队列为空，无法取出数据
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
1
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
2
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
3
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
h
取出的数据为：1
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
取出的数据为：1
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
取出的数据为：2
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[0]=1
arr[1]=2
arr[2]=3
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
h
取出的数据为：3
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
取出的数据为：3
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
h
当前队列为空，无法取出数据
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据

问题

  • 现在队列经历了加满 也全部取出 当前列表理论上为空
  • 但是任然无法加入数据 这个数组无法复用 只能使用一次 没有到达复用的效果
  • 需要将这个数组由算法改造成一个环形数组(取模)

如何解决：

思路如下:

  1. front变量的含义做一个调整:

    front就指向队列的第一个元素,也就是说arr[front]就是队列的第一个元素front的初始值=0

  2. rear变量的含义做一个调整:

rear指向队列的最后一个元素的后一个位置.因为希望空出一个空间做为约定.rear的初始值=0

  1. 当队列满时，条件是(rear +1) % maxSize == front【满】

  2. 对队列为空的条件，rear== front空

  3. 当我们这样分析，队列中有效的数据的个数(rear+ maxSize-front)% maxSize // rear= 1 front=0

  4. 我们就可以在原来的队列上修改得到，一个环形队列

//整理得：
定义修改：
    front = 0; rear = 0;
队列空得条件：
    rear == front;
队列满得条件：
    (rear+1)%maxSize == front;
队列中得元素个数：
    (rear+maxSize-front)%maxSize;//即当前循环队列中元素得个数

循环队列数组代码实现

package com.iswhl.queue;

import java.util.Scanner;

public class CircleQueueDemo {
    public static void main(String[] args) {
        //测试
        System.out.println("这里是环形数组的测试：");
        //由于我们使用了环形数组的最后一个空间，用来当作一个约定
        //所以，我们使用数组的时候，就会少一个地址空间
        //即开4个空间，只能使用3个空间，还有一个地址空间用来做约定
        CircleQueue circleQueue = new CircleQueue(4);
        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':
                    try {
                        circleQueue.showQueue();
                    } catch (Exception e) {
                        System.out.println("当前队列为空，无法取出数据");
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                case 'a':
                    try {
                        System.out.println("请输入您要添加的数据：");
                        int value = scanner.nextInt();
                        circleQueue.addQueue(value);
                    } catch (Exception e) {
                        System.out.println("队列已满，无法添加数据！");
                    }
                    break;
                case 'g':
                    try {
                        int queue = circleQueue.getQueue();
                        System.out.println("取出的数据为："+queue);
                    } catch (Exception e) {
                        System.out.println("当前队列为空，无法取出数据");
                    }
                    break;
                case 'h':
                    try {
                        int i = circleQueue.headQueue();
                        System.out.println("取出的数据为："+i);
                    } catch (Exception e) {
                        System.out.println("当前队列为空，无法取出数据");
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出~");
    }
}

class CircleQueue{
    private int maxSize;//数组的最大长度
    //front变量的含义做一个调整:
    //
    //front就指向队列的第一个元素,也就是说arr[front]就是队列的第一个元素`front的初始值=0`
    private int fornt;//数组的头部
    private int rear;//数组的尾部
    //rear变量的含义做一个调整:
    //
    //rear指向队列的最后一个元素的后一个位置.因为希望空出一个空间做为约定.`rear的初始值=0`
    private int[] arr;//定于数组的名称


    //编写模拟队列的构造器，用于初始化队列
    public CircleQueue(int arrMaxSize){
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        //这里得front与rear都是默认为0的，所以不需要进行赋值
    }
    //判断队列是否满了
    public boolean isFull(){
        return (rear+1)%maxSize == fornt;
    }
    //判断队列是否为空
    public boolean isEmpty(){
        return rear == fornt;
    }
    //给队列中添加数据
    public void addQueue(int n){
        if (isFull()) {
            throw new RuntimeException("队列已满，不能添加数据");
        }
        //由于rear就是指向环形数组中当前元素的下一个，所以添加数据时，可以直接添加（该位置的值就是空的）
        arr[rear] = n;
        //由于是环形数组，如果让arr一直加下去的话，会导致数组的越界
        //所以这里我们采用取模的方法来，将rear重新指向队尾
        rear = (rear+1)%maxSize;
    }
    //从队列中拿出数据
    public int getQueue(){
        if (isEmpty()){
            throw new RuntimeException("当前队列为空，无法取出数据");
        }
        //同样的fornt也一直指向队列的队首，这里我们找一个中间值来进行取值
        int value = fornt;
        fornt = (fornt+1)%maxSize;
        return arr[value];
    }
    //读取队列中的数据
    public void showQueue(){
        if (isEmpty()){
            throw new RuntimeException("当前队列为空，无法取出数据");
        }
        for (int i = fornt; i < fornt+size(); i++) {
            //因为front与rear一样
            //由于是循环数组，所以一直加的话，会数组越界，所以需要取模来找到，front在环形数组中的位置
            System.out.printf("arr[%d]=%d\n",i%maxSize,arr[i%maxSize]);
        }
    }
    //判断队列当中有多少元素
    public  int size(){
        return (rear+maxSize-fornt)%maxSize;
    }
    //读取队列头的值
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("当前队列为空，无法取出数据");
        }
        return arr[fornt];
    }
}

运行结果：


这里是环形数组的测试：
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
1
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[0]=1
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
2
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
3
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
4
队列已满，无法添加数据！
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[0]=1
arr[1]=2
arr[2]=3
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
h
取出的数据为：1
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
取出的数据为：1
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[1]=2
arr[2]=3
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
1
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[1]=2
arr[2]=3
arr[3]=1
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
取出的数据为：2
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[2]=3
arr[3]=1
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
2
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[2]=3
arr[3]=1
arr[0]=2
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
取出的数据为：3
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
取出的数据为：1
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
取出的数据为：2
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
当前队列为空，无法取出数据
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
1
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
2
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
3
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[1]=1
arr[2]=2
arr[3]=3
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
e
程序退出~

进程已结束,退出代码0

: 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
当前队列为空，无法取出数据
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
1
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
2
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
请输入您要添加的数据：
3
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[1]=1
arr[2]=2
arr[3]=3
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
e
程序退出~

进程已结束,退出代码0
三横同学
关注
专栏目录
数据结构与算法——队列（笔记）
weixin_44947339的博客
03-17 633
目录队列1、定义2、队列特点：先进先出(FIFO)3、队列的基本运算：4、队列的存储结构（1）队列的顺序存储。为了区别对空和队满的情况：设队列中的元素为整型，则循环队列的类型定义为：创建一个空的循环队列：判断队列是否为空元素入循环队列元素出循环队列（2）队列的链式存储5、队列的应用 队列 1、定义 队列是限定只能在表的一端进行插入，在表的另一端进行删除的线性表。 队尾(rear)——允许插入的一...
数据结构之队列
小小猿的博客
03-15 320
3 队列 3.1 队列的使用场景 例如我们去肯德基排队，先排上队的肯定先拿到餐出队，这和我们对列认知是一致的。 3.2 队列介绍 队列是一个 有序列表，可以用 数组或是 链表来实现。 遵循 先入先出的原则。即： 先存入队列的数据，要先取出。后存入的要后取出 队列（queue）是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作 进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。 队列的数据元素又称为队列元素。在队
java 数据结构与算法002---队列
独行侠的守望の博客
03-02 221
import java.util.Scanner; public class ArrayQueueDemo { public static void main(String[] args) { //测试一把 //创建一个队列 ArrayQueue queue = new ArrayQueue(3); char key = ' '; //接收用户输入 Sca...
数据结构和算法-队列
qq_39356904的博客
11-09 222
  队列是一种特殊的线性表，特殊之处在于它只允许在表的前端进行删除操作，而在表的后端进行插入操作(先入先出原则)，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 队列的使用场景 银行排队案例：   在银行排队办理业务的时候，如果窗口有人正在办理业务，后面等待的人会按照先后顺序排成一个队列，这个队列的人，先到的先从等待队列中出去办理业务，而后到的人要从这...
队列
qq_45772158的博客
08-18 190
1.队列介绍 1)队列是一个有序列表，可以用数组或是链表来实现。 2)遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 2.数组模拟队列思路 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图,其中maxSize是该队列的最大容量。 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量front及rear分别记录队列前后端的下标，front会随着数据输出而改变，而rear则是随着数据输入而改变，如图所示 当我们将数据存入队列时称为”addQueue”，
Java数据结构与算法02——队列
12-21
Java中的数据结构与算法是编程领域中至关重要的概念，它们为高效地处理和组织数据提供了...对于初学者来说，从简单的数组模拟开始，逐步深入到链表、环形队列以及更高级的队列实现，是学习数据结构与算法的有效路径。
Python实现数据结构与算法——队列的最大值
Mantana的博客
03-09 1617
题目描述： 请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。 若队列为空，pop_front 和 max_value 需要返回 -1 示例1： 输入: ["MaxQueue","push_back","push_back","max_value","pop_front","ma...
数据结构与算法——看病排队候诊问题.docx
10-10
数据结构与算法——看病排队候诊问题 数据结构是计算机科学中用于存储和组织数据的方式。队列是一种特殊的数据结构，遵循先入先出的原则，即最先进入队列的元素一定是最先被处理的。在解决看病排队候诊问题时，可以...
简单粗暴学习数据结构与算法——JS版（一）
06-13
这篇教程"简单粗暴学习数据结构与算法——JS版（一）"显然旨在帮助初学者或有一定基础的开发者通过JavaScript来深入理解这些概念。 首先，数据结构是存储和组织数据的方式，它决定了数据的访问效率和操作便利性。在...
创建队列 出队 入队 显示队列（链式）
weixin_30316097的博客
07-27 383
#include<stdlib.h> typedefintdatatype; /*定义节点存储入队元素和指向下一节点的指针*/ typedefstructnode{ datatypedata; structnode*next; }NODE; /*定义节点存放队尾和对首指针*/ typedefstruc...
（三）数据结构与算法-队列
qq_38949960的博客
01-06 471
银行排队案例 队列介绍 队列是一个有序列表，可以用数组或是链表来实现 遵循先入先出原则。即：先存入队列的数据，要先取出。后存入的要后取出 数组模拟队列 队列本身是有序表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图，其中maxSize是该队列的最大容量。 因为队列的输出、输入分别从前、后端来处理，因此需要两个变量front及rear分别记录队列的前后端的下标，front会随着数据输出而改变，而rear则是随着数据输入而改变。 数组模拟队列的示意图： 思路分析 当我们将数据存入队列时称
数据结构-队列
littesss的博客
06-15 578
一.顺序队列SeqQueue 1.顺序队列结构类型的成员：ElemType * base 、int front、int rear、size_t capacity,分别是base指针，头位置，尾位置，容量。和顺序表操作大致一样，只不过队列只能尾部插入，头部删除，只能使用一次，没多大的实际意义。 2.顺序队列的结构类型表示 3，出栈只需front++； 4.清理和摧毁函数
数据结构之【队列】
weixin_40989362的博客
08-09 732
队列：先进先出，就是一块线性表，必须从头front的一方出队，从尾巴rear一方入队 我们生活中的队列就是这样的，出队的时候每次必须从a1出队，           当头出队后，尾巴就向前移动到下标为0处，这样的效率太低了，我们应该提高效率，每次头front出队了，就不需要向前移动 队头不需要每次都向前移动 如果front==rear的时候队为空，每次入队一个尾巴就向后面移动...
显示队列内容
ssdut2013的专栏
02-29 1928
4.1 为queue.java 程序（清单4.4）的Queue类中写一个方法，显示队列的 内容。注意这并不是要简单的显示出数组的内容。它要求按数据项插入的队 列的顺序，从第一个插入的数据项到最后一个插入的数据项显示出来。不要 输出因为在数组末端回绕而折成两半的样子。注意无论front和rear在什么位置上，都要正确显示出一个数据项和没有数据项的情况。 public class Queue {
简单粗暴学习数据结构与算法——JS版(二)
06-14
本教程"简单粗暴学习数据结构与算法——JS版(二)"显然是为那些希望通过JavaScript来学习数据结构与算法的初学者或开发者设计的。 首先，我们来讨论数据结构。数据结构是指在计算机中组织和存储数据的方式，它决定了...
数据结构与算法---队列
weixin_51451819的博客
09-06 168
数据结构之队列 思路:使用数组实现 有关队列的描述 1.队头与队尾： 允许元素插入的一端称为队尾，允许元素删除的一端称为队头。 2.入队：队列的插入操作。 3.出队：队列的删除操作。 public class Arrayqueue { private int front; private int rear; private int arr[]; private int Maxsize; public Arrayqueue() { } public Arrayqueue(int Max
数据结构算法之队列
weixin_45825875的博客
03-28 116
队列 队列故事导入: 我们在银行办理业务时，一般是通过排队的方式办理，先来的先办理，后来的后办理。排队办理，顾名思义，这就是队列。 好来盗张图片,加深理解 队列它的特点的是先进先出，它可以是顺序式也可以是链式存储序列。 /* 队列 顺序表队列 特点是先进先出，有最大值 1、队列初始化 2、判断队列是否为空 3、判断队列元素是否已满 4、入队 5、出队，删除元素头，两种方法一种是速度慢但节约空间，另外一种速度快但是浪费空间 6、遍历 7、获取头节点 */ 结构特点: #define MAX_SIZE 10
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

三横同学

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

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

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

打赏作者

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

抵扣说明：

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

余额充值