队列与环形队列使用数组模拟

最新推荐文章于 2022-12-26 20:25:22 发布
最新推荐文章于 2022-12-26 20:25:22 发布
阅读量246 收藏 1
点赞数
分类专栏： 数据结构与算法(学习记录) 文章标签： 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fushuaiCSDN/article/details/107294588
版权

队列

该文是观看尚硅谷韩老师视频学习自己总结学习得,有的是来源于网络收集

队列引入

在这里插入图片描述
进的一端称为队尾（rear），出的一端称为队头（front）。队列可以用顺序存储，也可以用链式存储。

队列介绍

  1. 队列是一个**有序列表**，可以用数组或是链表来实现。
  2. 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出
  3. 示意图：(使用数组模拟队列示意图)

在这里插入图片描述

数组模拟队列

队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的 如上图,其中 maxSize 是该队列的最大容量。
在这里插入图片描述

思路分析
添加数据的时候将尾指针往后移：rear+1 , 当 取出的数据front+1,若front == rear 【所明队列数据为空,并非数组数据空,】
若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear 所指的数组元素中，否则无法存入数据。
rear = = maxSize - 1[队列满]

代码模拟数组实现队列

package com.fs.demo_2020_07_11_queueArray;

import java.util.Scanner;

/**
 * 队列
 * 队列是一个有序列表,可以用数组或者链表来实现
 * 遵循先入先出的原则,先存入的数据先取出来,后存入的后取出来
 *
 * 数组模拟队列
 */
public class QueueArray {
    public static void main(String[] args) {
        //测试一把
        //创建一个队列
        SimulationQueueArray queue = new SimulationQueueArray(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) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h': //查看队列头的数据
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
                    //   System.out.println(e.getMessage());
                        e.printStackTrace();
                    }
                    break;
                case 'e': //退出
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出~~");
    }
}

//创建一个类来模拟队列
class SimulationQueueArray {
    private int maxSize;//表示数字的最大容纳量
    private int front;//模拟指针,默认指向数组有效数据索引的前一个位置
    private int rear;//模拟指针指向尾部数据,默认初始化指向和front一个位置,因为没有数据
    private int[] arr;

    /**
     * 创建队列数组的构造器
     *
     * @param arrMaxSize 初始化这个队列数组的容量
     */
    public SimulationQueueArray(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];//初始化数组的容量
        front = -1;
        rear = -1;
    }

    //判断队列数组是否满了
    public boolean isFull() {
        //假设数组最大索引为2,那么容量就为3,当添加3个数据后,rear就加了3次,就是-1+3=2
        //所以-1+3 = 2 = 3 -1 = 2,所以就满了
        return rear == maxSize - 1;
    }

    //判断队列是否为空
    public boolean isEmpty() {
        //为空有两中情况,
        //1.就是数组中的元素取完了,我还是假设容量为3,要么一条数据都没有添加,front和rear都为-1,表示容量为空
        //2.数组中的元素添加3个,那么front为2,然后我们又取了3个元素,那么front也为2,那么rear=front,说明数组中为空
        return rear == front;
    }

    //添加数据到队列
    public void addQueue(int data) {
        //添加前先判断队列是否满了
        if (isFull()) {
            System.out.println("队列满,不能加入数据~~~");
            return;
        }
        rear++;//让指针向后移一下
        //在rear索引下添加这个数据,假设第一次添加,就是0索引添加data数据
        arr[rear] = data;
    }

    //获取队列的数据,出队列
    public int getQueue() {
        //先判断队列是否为空
        if (isEmpty()) {
            //为空就抛出异常,我们这里结束方法使用抛出异常方式
            throw new RuntimeException("队列空,不能获取数据~~~");
        }
        front++;//先将指针后移,
        //这里的取出并不是吧数组中的数据真正的取出,而且将指针后移,取出指针后移的这位数据
        //提现了先进先出的队列思想
        return arr[front];
    }

    //显示队列的所有数据
    public void showQueue() {
        //同样先判断队列是否为空
        if (isEmpty()) {
            System.out.println("队列空,没有这个数据~~~");
            return;
        }
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println("arr[" + i + "]=" + arr[i]);
        }
    }

    //显示队列的头数据,不是取数剧
    public int headQueue() {
        if (isEmpty()) {
            //为空就抛出异常,我们这里结束方法使用抛出异常方式
            throw new RuntimeException("队列空,没有数据~~~");
        }
        //显示是front指针当前指的哪位数据,因为假如还没有从列队中取出数据,那么当前就指向索引为0的位子,故为front+1 为0
        //若已经取了索引为0的数据,那么当前指的就是索引为1的位子,故front+1 为1
        //若数据已经取完,那么就判断直接抛出异常不会到这一步,假设到了这一步,也会索引越界异常
        return arr[front + 1];
    }

}

若看不懂,将代码拷贝到idea中DEBUG看数据变化自然会懂

上面是线性的队列,不能循环复用其中的排队逻辑,当队列满后,第一个走后,后来的不能加入子第一个位置,所以没有达到复用效果
使用一些取模的方式达到让线性的队列转换成环形队列,从而实现先进先出,后进后出,循环环形队列

数组模拟环形队列

上述到达尾部又向前存储的队列称为循环队列，为了避免"假溢出"，我们通常采用循环队列。

分析

一 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定,这个在做判断队列满的时候需要注意 (rear + 1) % maxSize == front 满]

二 rear == front [空]
在这里插入图片描述

代码实现环形队列

package com.fs.demo_2020_07_11_queueArray;

import java.util.Scanner;

/**
 * 模拟环形队列数组
 *
 * 1.头尾部指针取模重新计算指针值：(rear/front + 1) % maxSize
 * 2.队列空的判断逻辑：rear == front
 * 3.队列满的判断逻辑：(rear + 1) % maxSize == front
 * 4.队列内有效数据个数：(rear - front + maxSize) % maxSize
 *
 */
public class CircleQueueArray {
    public static void main(String[] args) {
        //测试一把
        //创建一个队列
        SimulationCircleQueueArray queue = new SimulationCircleQueueArray(4);

        char key = ' '; //接收用户输入
        Scanner scanner = new Scanner(System.in);//
        boolean loop = true;
        //输出一个菜单
        while (loop) {
            /**
             * 遍历打印下每次执完后数组中的数据
             */
            int[] arr = queue.getArr();
            System.out.println("-------------------------------------------------");
            for (int i = 0; i < arr.length; i++) {
                int i1 = arr[i];
                System.out.println("arr数组索引:"+i+"位子当前的数据为:"+i1+".");
            }
            System.out.println("-------------------------------------------------");
            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) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h': //查看队列头的数据
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
                        //   System.out.println(e.getMessage());
                        e.printStackTrace();
                    }
                    break;
                case 'e': //退出
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出~~");
    }
}

//创建一个类来模拟环形队列数组
class SimulationCircleQueueArray{
    private int maxSize;//表示数字的最大容纳量
    private int front;//模拟指针指向头部数据,对于普通的队列做了调整,现在默认指向第一个索引位子,也就是0
    private int rear;//模拟指针指向尾部数据,同样也是默认指向第一个索引的位子,也就是0
    private int[] arr;//数组用于存放数据,模拟队列

    //提供一个get方法观察数组中数据的变化
    public int[] getArr() {
        return arr;
    }

    /**
     * 创建环形队列数组的构造器
     *
     * @param arrMaxSize 初始化这个环形队列数组的容量
     */
    public SimulationCircleQueueArray(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];//初始化数组的容量
        front = 0;
        rear = 0;
    }

    //判断队列数组是否满了
    public boolean isFull() {
        /*
        判断队列是否满
        环形队列,判断队列满,不仅仅在通过rear = maxSize -1 来判断
        因为是环形,尾部指针会回到之前的位子,所以通过取模来重新计算指针的值(rear+1)%maxSize == front;

        假设队列内部数组arr的最大容量为4
        队列添加数据，rear指针需取模重新计算指针指向值：rear = (rear + 1) % maxSize，并通过(rear + 1) % maxSize == front来判断队列是否已满
            1.队列添加数据10，arr[0]=10，rear重新指向1，(1+1)%4!=0，队列未满
            2.队列添加数据20，arr[1]=20，rear重新指向2，(2+1)%4!=0，队列未满
            3.队列添加数据30，arr[2]=30，rear重新指向3，(3+1)%4==0，队列满，不能再添加数据
            此时，队列内所有数据为：arr[0]=10,arr[1]=20,arr[2]=30，队列有效数据个数：(3-0+4)%4=3

         */
        return (rear+1)%maxSize == front;
    }

    //判断队列是否为空
    public boolean isEmpty() {
        /*
            队列当取得指针和添加的指针一致的时候,所明去完了,没有数据
         */
        return rear == front;

    }

    //添加数据到队列
    public void addQueue(int data) {
        /*
        队列的添加:
            一般线性队列,尾部指针直接递增
            而环形队列,尾部指针可能在次指向索引为0的位子,因此不能单一的通过递增来处理,需要取模重新计算尾部的指针位置
         */
        //添加前先判断队列是否满了
        if (isFull()) {
            System.out.println("队列满,不能加入数据~~~");
            return;
        }
        arr[rear] = data;//在尾部指针指向的位子添加传递的数据

        //添加值后,尾部指针的走向不能在++递增来实现,需要从新取模运算
        rear = (rear + 1)%maxSize;

    }

    //获取队列的数据,出队列
    public int getQueue() {
        /*
        环形列队取数据:
            和添加数据一样,添加是尾部指针不能一直递增,需要取模重新计算尾部指针的位子
            而头部指针在每次取出数据后也不能一直递增,需要取模让指针回到最初的位子
         */
        //先判断队列是否为空
        if (isEmpty()) {
            //为空就抛出异常,我们这里结束方法使用抛出异常方式
            throw new RuntimeException("队列空,不能获取数据~~~");
        }
        //先获取到头部指针指向的索引位子获取出数据
        int value = arr[front];
        //对取模计算出下一次头部指针的位子
        front = (front + 1) % maxSize;
        //将数据返回
        return value;
    }

    /**
     * 显示队列所有的数据
     */
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列为空，无法显示队列的全部数据");
            return;
        }
        // 遍历数组
        // 不能单一的对角标递增处理，会出现角标越界异常
        // 应对环形队列内部的有效数据，从头部数据开始遍历依次取出
        // 有效数据的下标：i % maxSize
        for (int i = front; i < front + size(); i++) {
            System.out.printf("arr[%d] = %d\n", i % maxSize, arr[i % maxSize]);
        }
    }

    /**
     * 获取队列有效数据的个数
     * @return 队列有效数据的个数
     */
    private int size() {
        return (rear - front + maxSize) % maxSize;
    }


    //显示队列的头数据,不是取数据
    public int headQueue() {
        /*
        获取列队头部数据
            就是获取头部指针指向的位子
         */
        if (isEmpty()) {
            //为空就抛出异常,我们这里结束方法使用抛出异常方式
            throw new RuntimeException("队列空,没有数据~~~");
        }
        return arr[front];
    }
}
代码运行控制台测试
D:\Java\JDK\java1.8
-------------------------------------------------
arr数组索引:0位子当前的数据为:0.
arr数组索引:1位子当前的数据为:0.
arr数组索引:2位子当前的数据为:0.
arr数组索引:3位子当前的数据为:0.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
a
输出一个数
10
-------------------------------------------------
arr数组索引:0位子当前的数据为:10.
arr数组索引:1位子当前的数据为:0.
arr数组索引:2位子当前的数据为:0.
arr数组索引:3位子当前的数据为:0.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
a
输出一个数
20
-------------------------------------------------
arr数组索引:0位子当前的数据为:10.
arr数组索引:1位子当前的数据为:20.
arr数组索引:2位子当前的数据为:0.
arr数组索引:3位子当前的数据为:0.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
a
输出一个数
30
-------------------------------------------------
arr数组索引:0位子当前的数据为:10.
arr数组索引:1位子当前的数据为:20.
arr数组索引:2位子当前的数据为:30.
arr数组索引:3位子当前的数据为:0.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
s
arr[0] = 10
arr[1] = 20
arr[2] = 30
-------------------------------------------------
arr数组索引:0位子当前的数据为:10.
arr数组索引:1位子当前的数据为:20.
arr数组索引:2位子当前的数据为:30.
arr数组索引:3位子当前的数据为:0.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
g
取出的数据是10
-------------------------------------------------
arr数组索引:0位子当前的数据为:10.
arr数组索引:1位子当前的数据为:20.
arr数组索引:2位子当前的数据为:30.
arr数组索引:3位子当前的数据为:0.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
s
arr[1] = 20
arr[2] = 30
-------------------------------------------------
arr数组索引:0位子当前的数据为:10.
arr数组索引:1位子当前的数据为:20.
arr数组索引:2位子当前的数据为:30.
arr数组索引:3位子当前的数据为:0.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
g
取出的数据是20
-------------------------------------------------
arr数组索引:0位子当前的数据为:10.
arr数组索引:1位子当前的数据为:20.
arr数组索引:2位子当前的数据为:30.
arr数组索引:3位子当前的数据为:0.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
s
arr[2] = 30
-------------------------------------------------
arr数组索引:0位子当前的数据为:10.
arr数组索引:1位子当前的数据为:20.
arr数组索引:2位子当前的数据为:30.
arr数组索引:3位子当前的数据为:0.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
h
队列头的数据是30
-------------------------------------------------
arr数组索引:0位子当前的数据为:10.
arr数组索引:1位子当前的数据为:20.
arr数组索引:2位子当前的数据为:30.
arr数组索引:3位子当前的数据为:0.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
g
取出的数据是30
-------------------------------------------------
arr数组索引:0位子当前的数据为:10.
arr数组索引:1位子当前的数据为:20.
arr数组索引:2位子当前的数据为:30.
arr数组索引:3位子当前的数据为:0.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
h
java.lang.RuntimeException: 队列空,没有数据~~~
	at com.fs.demo_2020_07_11_queueArray.SimulationCircleQueueArray.headQueue(CircleQueueArray.java:203)
	at com.fs.demo_2020_07_11_queueArray.CircleQueueArray.main(CircleQueueArray.java:60)
-------------------------------------------------
arr数组索引:0位子当前的数据为:10.
arr数组索引:1位子当前的数据为:20.
arr数组索引:2位子当前的数据为:30.
arr数组索引:3位子当前的数据为:0.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
s
队列为空，无法显示队列的全部数据
-------------------------------------------------
arr数组索引:0位子当前的数据为:10.
arr数组索引:1位子当前的数据为:20.
arr数组索引:2位子当前的数据为:30.
arr数组索引:3位子当前的数据为:0.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
a
输出一个数
40
-------------------------------------------------
arr数组索引:0位子当前的数据为:10.
arr数组索引:1位子当前的数据为:20.
arr数组索引:2位子当前的数据为:30.
arr数组索引:3位子当前的数据为:40.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
a
输出一个数
50
-------------------------------------------------
arr数组索引:0位子当前的数据为:50.
arr数组索引:1位子当前的数据为:20.
arr数组索引:2位子当前的数据为:30.
arr数组索引:3位子当前的数据为:40.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
a
输出一个数
60
-------------------------------------------------
arr数组索引:0位子当前的数据为:50.
arr数组索引:1位子当前的数据为:60.
arr数组索引:2位子当前的数据为:30.
arr数组索引:3位子当前的数据为:40.
-------------------------------------------------
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据

环形队列的解释

下面解释来源于网络收集
作者：rainchxy
链接：https://www.jianshu.com/p/9ba8a65464dd
来源：简书

为什么要%Maxsize呢？

主要是为了处理临界状态，即Q.rear向后移动一个位置Q.rear+1后，很有可能超出了数组的下标，这时它的下一个位置其实是0，如果将一维数组画成环形图，如图所示：
在这里插入图片描述
上图中最大空间Maxsize，当Q.rear=Maxsize-1时，(Q.rear+1)%Maxsize=0，而且Q.front=0，正好满足队满的条件：(Q.rear+1) %Maxsize= Q.front，此时为队满。

因此无论是front还是rear向后移动一个位置时，都要加1与最大空间Maxsize取模运算，处理临界问题。

总结：

队空：Q.front=Q.rear; // Q.rear和Q.front指向同一个位置

队满： (Q.rear+1) %Maxsize=Q.front; // Q.rear向后移一位正好是Q.front

入队：

Q.base[Q.rear]=x; //将元素放入Q.rear所指空间，

Q.rear =( Q.rear+1) %Maxsize; // Q.rear向后移一位

出队：

e= Q.base[Q.front]; //用变量记录Q.front所指元素，

Q.front=(Q.front+1) %Maxsize // Q. front向后移一位

努力敲代码买猪脚啃
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java数组实现队列及环形队列实现过程解析
08-25
主要介绍了java数组实现队列及环形队列实现过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java----循环队列
王以牧
06-14 2567
文章目录一、什么是循环队列二、循环队列的简单实现1、简单图示2.数组下标循环的小技巧：总结 一、什么是循环队列 为充分利用向量空间，克服"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。循环队列是把顺序队列首尾相连，把存储队列元素的表从逻辑上看成一个环，成为循环队列。 循环队列就是将队列存储空间的最后一个位置绕到第一个位置，形成逻辑上的环状空间，供队列循环使用。在循环队列结构中，当存储空间的最后一个位置已被使用
JAVA算法-队列
qq_42913729的博客
11-02 379
队列的一个使用场景 银行排队的案例: 队列介绍 队列是一个有序列表，可以用数组或是链表来实现。 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 示意图：(使用数组模拟队列示意图) - 数组模拟队列思路 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队 列的最大容量。 因为队列的输出、输入是分别从前后...
队列数组实现-环形队列
weixin_64650214的博客
12-26 155
队列-->数组实现
数据结构——队列
baolingye的博客
08-23 233
一、队列简介 队列是一个有序列表，可以用数组或是链表来实现。 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 示意图：(使用数组模拟队列示意图) 二、数组实现队列 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量 因为队列的输入、输出分别是从前后端来处理的，因此需要两个变量fro...
用数组实现环形队列（尚硅谷Java数据结构与算法）
ALi的博客
09-12 492
整个代码在文章最后面，gitee地址：java数据结构与算法: 自己学习与练习数据结构的仓库https://gitee.com/ALi_L/javaDataStructurs.git 环形队列的难点如下： 1.如何判断队列已经满了 2.如何判断队列是空的 3.如何打印队列 4.如何增加一个元素到队列 解决方法： 首先用front指向队列的首元素地址，用rear指向队列最后一个元素后面的地址，队列的属性如下：。 private int maxSize; private int
【数据结构与算法】环形队列的介绍、用数组实现环形数组
Bulut0907
09-09 1101
队列是一个有序列表，遵循先入先出的原则。可以用数组或链表来实现而环形队列，通过取模的方式，将数组看做是一个环形的。
【Java 环形队列的图解分析 代码实现】简单理解
qq_44682003的博客
03-04 247
一、队列 队列和我们学过的栈有相似之处，我们都知道，栈遵循先进后出的原则，只有一个口，既是入口也是出口；队列，有两个口，一个出口，一个入口，遵循先进先出的原则。 二、环形队列的实现 首先我们了解了解java中的求余运算符：%，求余数 假设以 0 1 2 3 4 5 为例：这size = 6 个数字我们知道每个数字+1就是他后面的数字，那当走到数字5的时候，没路了，我们想返回0，然后接着从0开始...
队列
miracleiii的博客
08-19 108
队列是一个有序列表，可以用数组或者链表实现。 队列先入先出，与栈的先入后出有区别。 下面是用数组实现队列的代码 package com.queue; import java.util.Scanner; public class ArrayQueueDemo { public static void main(String[] args) { ArrayQueue queue = new ArrayQueue(3); char key = ' ';//接受用户输入 Scanner sca
实现环形数组队列
sssuperqiqi的博客
06-18 9026
看到一个很棒的环形数组队列实现方法，转载过来。 原网址：https://blog.csdn.net/xuanwolanxue/article/details/68925446 话不多说，上重点： 这里主要指的是队列的入队（enqueue）与出队（dequeue），对于链式队列来说，其入队和出队也就是链表的尾部插入与移除头部节点，这里就不多说...
用C语言编写的 杂货店系统
10-04
如果不清楚请加QQ149557547（注明csdn帮助）
PHP使用数组实现队列
10-28
PHP的数组处理函数还可以将数组实现队列，堆栈是“先进后出”。在堆栈中，最后压入的数据（进栈），将会被最先弹出（出栈）。而队列是先进先出，就如同银行的排号机
JS使用数组实现的队列功能示例
10-17
主要介绍了JS使用数组实现的队列功能,结合实例形式分析了javascript基于数组的队列定义、元素添加、读取等相关操作技巧,需要的朋友可以参考下
同步队列-无锁队列-循环数组无锁队列.zip
05-14
配套代码讲解：https://blog.csdn.net/songchuwang1868/article/details/90200251 ...同步队列-无锁队列-循环数组无锁队列 同步队列-无锁队列-循环数组无锁队列 同步队列-无锁队列-循环数组无锁队列
2024-2030全球及中国PCB接触式探头行业研究及十五五规划分析报告.docx
04-18
2024-2030全球及中国PCB接触式探头行业研究及十五五规划分析报告
网站界面设计mortal0418代码
04-18
网站界面设计mortal0418代码
PHP毕业设计-校园失物招领系统源码+数据库.zip
04-18
PHP毕业设计-校园失物招领系统源码+数据库.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码、该项目可以直接作为毕设使用。项目都经过严格调试，确保可以运行！ PHP毕业设计-校园失物招领系统源码+数据库.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码、该项目可以直接作为毕设使用。项目都经过严格调试，确保可以运行！ PHP毕业设计-校园失物招领系统源码+数据库.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码、该项目可以直接作为毕设使用。项目都经过严格调试，确保可以运行！ PHP毕业设计-校园失物招领系统源码+数据库.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可
2024年神经酸行业分析报告.pptx
最新发布
04-18
2024年神经酸行业分析报告.pptx
Java爬虫信息抓取的实现 完整实例（源码）
04-18
【Java爬虫】信息抓取的实现 完整实例（源码）
数组模拟环形队列代码实现
03-13
以下是一个简单的数组模拟环形队列的代码实现： ``` #define MAXSIZE 100 // 队列的最大长度 typedef struct { int data[MAXSIZE]; // 存储队列元素的数组 int front; // 队头指针 int rear; // 队尾指针 } ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值