队列是什么？

5W1H

5W：

1. What ？有序线性表，但是插入和删除在线性表的两个不同端点进行
2. Where ？任何资源受限的地方，比如食堂排队打饭的时候
3. When ？任何资源受限的时侯，以前计算机只有一个CPU，进程需要排队进行运算
4. Who ？任何资源受限的对象，比如搬家的蚂蚁，需要跟着前一只蚂蚁
5. Why  ？资源受限

 

How？：

1. 先进先出，FIFO

 

抽象数据类型（Abstract Data Type，ADT）

得有

• 队列的头 front，正在打饭的小胖
• 队列的屁股 rear，刚刚排上队的你

然后就是一些方法：

• 创建队伍，指定这个队伍最多能排多少人  queue...
• 队伍这么长，还能排下人吗？ boolean...
• 新来一个排队的小蜗，现在队伍满了吗？  boolean...
• 小胖打饭结束，然后队列的头 front变成了小飞  queue ...
• 现在排队打饭有多少人？boolean...

 

储存层面分类

逻辑层面就是上面阐述的这样，那储存层面呢？依旧还是分为

1. 顺序存储
2. 链式存储

 

顺序存储，同数组实现的两种方式

• 方式一：食堂打饭，小胖打完饭，所有人都往前移动

缺点：队伍一直在移动，每个打饭的人都要动，其实就是删的话，资源开销大

可惜，方式一并不是队列的官方定义，官方定义是方式二

• 方式二：小朋友在教室排好队（小朋友不移动），等着老师发苹果，老师是移动得给小朋友发苹果，小朋友得到苹果就跑去玩了，同时有新的小朋友入队
• 

溢出现象：

（1） "下溢"现象：当队列为空时，做出队运算产生的溢出现象。“下溢”是正常现象，常用作程序控制转移的条件。

（2）"真上溢"现象：当队列满时，做进栈运算产生空间溢出的现象。“真上溢”是一种出错状态，应设法避免。

（3）"假上溢"现象：由于入队和出队操作中，头尾指针只增加不减小，致使被删元素的空间永远无法重新利用。当队列中实际的元素个数远远小于向量空间的规模时，也可能由于尾指针已超越向量空间的上界而不能做入队操作。该现象称为"假上溢"现象。

教室没这么长啊，老师很可能从一端走到另一端，已经拿了苹果跑了的小盆友原来站的地方的空间是浪费的：假溢出

解决办法：去操场吧，我老师大不了围着操场转圈圈嘛，循环队列

 

 

循环队列

但循环队列有一个问题，

队列空的时候：头的位置==屁股的位置

队列满的时候：头的位置==屁股的位置

空or满？咋判断

也是两个方案：

1. ADT里再加一个变量：记录当前队列的Size
2. 少用数组的一个元素：

假设数组大小是n，那我队列的大小m就是n-1

1. 队列空的时候：头的位置==屁股的位置

   队列满的时候：（屁股的位置+1）%m ==头的位置

 

案例实现

采用顺序存储（数组），性能好的方式（老师移动），循环队列（操场），少用数组的一个元素

自己脑补的例子：

假设圆形操场是5个格子，小刘老师在第1个格子，给小朋友发苹果，，小朋友排好队（小朋友不移动），等着老师发苹果，老师是移动的给小朋友发苹果，小朋友得到苹果就跑去玩了。

规则是：先来一个老师，然后来三个小朋友排队，撤一个小朋友，来三个小朋友排队，撤一个小朋友，依次循环。老师算0号学生，小朋友学号从1号开始

问，当操场满的时候，小刘老师的位置，此时几号小朋友等待着领取苹果，几号小朋友在队伍的最后面，几号小朋友刚好被挤出插不进队伍

分析：

操场5个格子，老师就是队列的头

这个老师，不是队列的头，老师可不会被剔除，我居然忘记考虑了，所以这个不是普通的循环队列!!!!!!!!!!!!!!!!!!!!!!!!!!!

因为老师不属于队列，所以队列的大小是4，而数值需要留一个位置来判断，再加上老师占了一个位置，所以数组的大小是4+1+1=6

 

学生类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor

public class Student {
    private String name;
    private int id;

}

队列：

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor

public class Queue {
    //正常应该用ArrayList存学生对象，但是我们用的数组，所以存的是学生的学号
    public int[] queueArray;
    private int maxSize;
    private int front;//front指的是老师，front的下一个才是队列的头
    private int rear;

    public Queue(int max){
        maxSize=max+1;//数组要比队列大1位，还有一个老师，所以是6位
        queueArray=new int[maxSize];
        front=0;
        rear=0;
    }

//    队列满的时候：（屁股的位置+2）%m ==头的位置
    public boolean isFull(Queue queue){
        return (queue.rear+2)%(maxSize)==queue.front ? true:false ;
    }


//    队列空的时候：头的位置==屁股的位置
    public boolean isEmpty(Queue queue){
        return queue.front==queue.rear ? true:false ;
    }


    public boolean add(Queue queue,int i){
        if(isFull(queue)) return false;
        else{
            rear=(rear+1)%(maxSize);
            queueArray[rear]=i;
            return true;
        }
    }


    public void delete(Queue queue){
        if(isEmpty(queue)) {
            System.out.println("错误，没有元素给你删");
        }
        else {
            front= (front+1)%(maxSize);
            queueArray[front]=-2;//把原先的元素删了,-2就表示值为空
        }
    }


}

 

 

 

import java.util.ArrayList;

public class Exe {
    public static void main(String[] args) {

        ArrayList<Student> student=new ArrayList();

        student.add(new Student("学生0号，即老师",0));

        for (int i = 1; i <1000; i++) {
            student.add(new Student("学生"+i+"号",i));
        }


        int MaxSize=5;//操场能站下5个人，其中一个是老师，那么队列长度是4
        Queue queue=new Queue(MaxSize);

         //进三个同学，撤一个同学
        int j=1;
        System.out.print("开始前front = " + queue.getFront()+"     ");
        System.out.println("rear = " + queue.getRear());
        while(!queue.isFull(queue)){
            for (int i = 0; i <3 ; i++) {
                if(!queue.add(queue,student.get(j++).getId())) {
                    j--;
                    break;
                }

            }
            if(!queue.isFull(queue)) {
                queue.delete(queue);
                j++;
            }
        }
        System.out.print("满的时候front = " + queue.getFront()+"     ");
        System.out.println("rear = " + queue.getRear());
        System.out.println("队列头学生的格子"+queue.getFront()+1);
        System.out.println("队列头学生的名字"+student.get(queue.getFront()+1).getName());
        System.out.println("队列尾学生的格子"+queue.getRear());
        System.out.println("队列尾学生的名字"+student.get(queue.getRear()).getName());
        System.out.println("老师的位置是"+(queue.getFront()));
    }
}

 

 

 

 

 

 

 

链式存储

 

案例实现

待更新