队列

1、简介

1）队列是一个有序列表，可以用数组或者链表来实现

2）遵循先进先出的规则，即先进队的先出队

2、数组模拟队列

数组模拟队列的代码实现:

front：指向队头的前一个数据

rear：指向队尾

/**
 * @author houChen
 * @date 2020/7/26 10:09
 * @Description:   使用数组来模拟队列
 */
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("s:显示队列");
            System.out.println("e:退出程序");
            System.out.println("a:添加数据到队列");
            System.out.println("g:从队列取出数据");
            System.out.println("h:查看队列头的数据");

            key=scanner.next().charAt(0);
            switch (key){
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.print("输入一个数：");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
                        queue.getQueue();
                    } catch (Exception e) {
                        System.out.printf(e.getMessage());
                    }
                    break;
                case 'h':

                    try {
                        int v= queue.headQueue();
                        System.out.printf("从队头取出的元素为：%d",v);
                    } catch (Exception e) {
                        System.out.printf(e.getMessage());
                    }

                    break;
                case 'e':
                    scanner.close();
                    loop=false;
                    break;
            }
            System.out.println();
        }
        System.out.println("程序退出~~");
    }


}


class ArrayQueue{

    private int maxSize; //表示数组的最大容量
    private int front;  //队列头
    private int rear;   //队列尾
    private int[] array; //存放数据

    // 创建队列的构造器
    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        array =new int[maxSize];
        front=-1;
        rear = -1;
    }

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

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

    // 添加数据到队列 addQueue
    public void addQueue(int a){
        if(isFull()){
            System.out.println("队列已满，不能添加数据！！");
            return;
        }
        array[++rear]=a;
    }

    // 数据出队列 getQueue
    public void getQueue(){
        if(isEmpty()){
            throw new RuntimeException("队列为空,不能出队！！");
        }
        int a = array[++front];
        System.out.printf("出队数据为%d",a);
    }

    // 显示队列的所有数据 showQueue
    public void showQueue(){
        if(isEmpty()){
            System.out.println("队列为空！！！");
            return;
        }
        System.out.println("队列为:");
        for(int i=0;i<array.length;i++){
            System.out.printf("%d	",array[i]);
        }
        System.out.println();
    }

    // 显示队列头的数据，注意不是取出数据 headQueue
    public int headQueue(){
        if(isEmpty()){
            throw new RuntimeException("队列为空！！！");
        }
        return array[front+1];
    }
}

3、数组模拟环形队列

1）目前数组使用一次就不能使用，没有达到复用的效果

2）将这个数组使用算法，改进成一个环形的队列

【注意：自己理解】为什么要预留一个空位？（即：数组有八个位置 0-7，为什么入队到6处就算满了）

这是因为：

当从0入队到7时，rear此时指向的位置为 （7+1）% 8 = 0，rear == front

这就和判断队列为空重复了，为了避免两种情况混淆，就将maxSize-1（8-1=7）作为环形队列存储元素的最大个数

代码实现

front:指向对头

rear：指向队尾的下一个元素

public class CircleArrayQueueDemo {
    public static void main(String[] args) {
        CircleArray queue =new CircleArray(3);
        char key = ' ';
        Scanner scanner = new Scanner(System.in);
        boolean loop =true;
        while(loop){
            System.out.println("s:显示队列");
            System.out.println("e:退出程序");
            System.out.println("a:添加数据到队列");
            System.out.println("g:从队列取出数据");
            System.out.println("h:查看队列头的数据");

            key=scanner.next().charAt(0);
            switch (key){
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.print("输入一个数：");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
                        queue.getQueue();
                    } catch (Exception e) {
                        System.out.printf(e.getMessage());
                    }
                    break;
                case 'h':

                    try {
                        int v= queue.headQueue();
                        System.out.printf("从队头取出的元素为：%d",v);
                    } catch (Exception e) {
                        System.out.printf(e.getMessage());
                    }

                    break;
                case 'e':
                    scanner.close();
                    loop=false;
                    break;
            }
            System.out.println();
        }
        System.out.println("程序退出~~");
    }
}


class CircleArray{
    private int maxSize; //表示数组的最大容量
    private int front;  //指向队头              默认为0
    private int rear;   //指向队尾的后一个位置    默认为0
    private int[] array; //存放数据

    // 创建队列的构造器
    public CircleArray(int maxSize) {
        this.maxSize = maxSize;
        array =new int[maxSize];
    }

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

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

    // 添加数据到队列 addQueue
    public void addQueue(int a){
        if(isFull()){
            System.out.println("队列已满，不能添加数据！！");
            return;
        }
        array[rear]=a;
        rear=(rear+1)%maxSize;
    }

    // 数据出队列 getQueue
    public void getQueue(){
        if(isEmpty()){
            throw new RuntimeException("队列为空,不能出队！！");
        }
        int a = array[front];
        front=(front+1)%maxSize;
        System.out.printf("出队数据为%d",a);
    }

    // 显示队列的所有数据 showQueue
    public void showQueue(){
        if(isEmpty()){
            System.out.println("队列为空！！！");
            return;
        }
        //从front遍历，遍历多少个元素
        System.out.println("队列为:");
        for(int i=front;i<front+size();i++){
            System.out.printf("%d	",array[i%maxSize]);
        }
        System.out.println();
    }

    //队列的长度
    public int size(){
        return (rear+maxSize-front)%maxSize;
    }


    // 显示队列头的数据，注意不是取出数据 headQueue
    public int headQueue(){
        if(isEmpty()){
            throw new RuntimeException("队列为空！！！");
        }
        return array[front];
    }
}