队列

队列（queue）

队列介绍

队列是一个有序列表,可以用数组或是链表来实现，遵循先入先出的原则。即:先存入队列的数据,要先取出，后存入的要后取出。

数组模拟队列
队列本身是有序列表,若使用数组的结构来存储队列的数据,则队列数组的声明如下图,其中 maxSize是该队列的最大容量
因为队列的输出、输入是分别从前后端来处理,因此需要两个变量font及rear分别记录队列前后端的下标, front会随着数据输出而改变,而rear则是随着数据输入而改变,如图所示

将数据存入队列的处理需要有两步

1)将尾指针往后移:rear+1,当 front==rear
2)若尾指针rear小于队列的最大下标 maxSize-1,则将数据存入rear所指的数组元素中,否则无法存入数据。rear==maxSize-1[队列满]

代码实现:

//rear是队列最后[含], front是队列最前元素[不含]
/**
 * 使用数组创建队列
 */
public class ArrayQueue {

    public static void main(String[] args) {
        ArrayQueue arrayQueue = new ArrayQueue();
        ArrQueue arrQueue = new ArrQueue(3);
        Scanner scanner = new Scanner(System.in);
        boolean flag = true;
        int num;
        while (flag) {
            System.out.println("请选择以下操作：\n1.入队\n2.出队\n3.显示队列\n4.显示队头\n5.退出");

            num = scanner.nextInt();
            switch (num) {
                case 1:
                    try {
                        System.out.println("输入一个入队数：");
                        num = scanner.nextInt();
                        arrQueue.put(num);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }

                    break;
                case 2:
                    try {
                        arrQueue.get();
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }

                    break;
                case 3:
                    System.out.println("队列所有数据如下：");
                    arrQueue.show();
                    break;
                case 4:
                    try {
                        System.out.println("队列头数据如下：");
                        System.out.println(arrQueue.headQueue());
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }

                    break;
                case 5:
                    flag = !flag;
                    break;
                case 6:
                    System.out.println("无效输入，重输");
                    break;
            }
        }
    }
}

class ArrQueue {

    private int maxSize;//最大长度
    private int front;//头指针
    private int rear;//尾指针
    private int[] queue;//数组模拟队列

    public ArrQueue(int size) {
        this.maxSize = size;
        queue = new int[maxSize];
        front = -1;//指向头部顶部
        rear = -1;//指向头部尾部
    }

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


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

    //添加数据到队列
    public void put(int n) {

        if (isFull()) {
            System.out.println("队列已满");
            return;
        }

        queue[++rear] = n;
    }

    // 减少队列数据
    public int get() {

        if (isEmpty()) {
            throw new RuntimeException("队列空，不能取数据");
        }

        front++;
        return queue[front];
    }


    //显示队列所有数据
    public void show() {
        if (isEmpty()) {
            throw new RuntimeException("队列空，没有数据");
        }

        for (int i = 0; i < queue.length; i++) {
            System.out.printf("queue[%d]=%d  ", i, queue[i]);
        }
    }

    //显示头数据
    public int headQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列空，没有数据");
        }

        return queue[front + 1];
    }


}

拓展：

进一步将原来的队列上修改为一个环形队列，思路如下

1. front 变量的含义做一个调整: front 就指向队列的第一个元素,也就是说arr[front]就是队列的第一个元素front的初始值=0
2. rear变量的含义做一个调整: rear 指向队列的最后一个元素的后一个位置.因为希望空出一个空间做为约定.rear的初始值=0
3. 当队列满时，条件是(rear + 1) % maxSize= front [满]
4. 对队列为空的条件，rear== front空
5. 当我们这样分析，队列中有效的数据的个数(rear + maxSize - front) % maxSize // rear= 1  front=0
6. 我们就可以在原来的队列上修改得到，一个环形队列

代码实现：

public class ArrayQueue {

    public static void main(String[] args) {

        CircleQueue queue = new CircleQueue(4);

        Scanner scanner = new Scanner(System.in);
        boolean flag = true;
        int num;
        while (flag) {
            System.out.println("请选择以下操作：\n1.入队\n2.出队\n3.显示队列\n4.显示队头\n5.退出");

            num = scanner.nextInt();
            switch (num) {
                case 1:
                    try {
                        System.out.println("输入一个入队数：");
                        num = scanner.nextInt();
                        queue.put(num);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }

                    break;
                case 2:
                    try {
                        queue.get();
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }

                    break;
                case 3:
                    System.out.println("队列所有数据如下：");
                    queue.show();
                    break;
                case 4:
                    System.out.println("队列头数据如下：");
                    try {
                        System.out.println(queue.headQueue());
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }

                    break;
                case 5:
                    flag = !flag;
                    break;
                case 6:
                    System.out.println("无效输入，重输");
                    break;
            }
        }
    }
}


class CircleQueue {


    private int maxSize;//最大长度
    /*
        front = 0;//指向头部顶部,默认值就是0
        rear = 0;//指向头部尾部,默认值就是0
     */
    private int front;//头指针
    private int rear;//尾指针
    private int[] queue;//数组模拟队列

    public CircleQueue(int size) {
        this.maxSize = size;
        queue = new int[maxSize];
    }

    public boolean isFull() {
        return (rear + 1) % maxSize == front;//头指针不变的情况下，当尾指针指倒数第二个数时，加一后与maxSize取余正好为0，等于front
    }

    public boolean isEmpty() {
        return rear == front;
    }

    public void put(int n) {
        if (isFull()) {
            System.out.println("队列已满");
            return;
        }

        queue[rear] = n;
        rear = (rear + 1) % maxSize;
    }

    public int get() {

        if (isEmpty()) {
            throw new RuntimeException("队列空，不能取数据");
        }

        int v = queue[front];
        front = (front + 1) % maxSize;
        return v;
    }


    public void show() {
        if (isEmpty()) {
            throw new RuntimeException("队列空，没有数据");
        }

        for (int i = front; i < front + size(); i++) {
            System.out.printf("queue[%d]=%d  ", i % maxSize, queue[i % maxSize]);
        }
    }


    public int size() {
        return (rear + maxSize - front) % maxSize;
    }


    //显示头数据
    public int headQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列空，没有数据");
        }

        return queue[front];
    }
}