Java基础算法之------队列

队列

什么叫队列，我们去餐厅排队，去银行排队都是队列，遵循先进先出的原则，即先存入的数据先取出。

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

分析：

我们知道队列是有序的，所以当我们用数组来实现时，我们需要考虑指针位置的关系，看上图，

1. 当我们的队列中没有元素时我们的头指针和尾指针指向同一个位置
2. 当我们逐渐添加元素时，rear指针不断上移
3. 当我们取出元素时，，front指针逐渐上移

指针就是数组的下标，首先我们要定义两个个指针front = -1，和rear=-1，因为刚初始化数组队列时，数组队列里面没有数据，我们不能将指针指向下标为0的位置，所以当我们在添加数据时，我们需要将rear下标+1，在取出数据时我们需要将front的下标+1。

代码

package com.toulan.queue;

import java.util.Scanner;

/**
 * @author loltoulan
 * @version 1.0.0
 * @time 2020/3/30 22:00
 * @message
 */
public class ArrayQueueDemo {
    public static void main(String[] args) {
        ArrayQueue queue = new ArrayQueue();
        System.out.println(queue.getMaxSize());
        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) 查看队列头的数据");
            System.out.println("r(rear) 查看队列尾的数据");
            key = scanner.next().charAt(0);
            switch (key){
                case 's':
                    queue.showQueue();
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                case 'a':
                    System.out.println("请输入一个数字:");
                    int value  = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
                        int result = queue.getQueue();
                        System.out.println("从队列中取出的数据是："+result);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int result = queue.headQueue();
                        System.out.println("队列的头数据是："+result);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'r':
                    try {
                        int result = queue.rearQueue();
                        System.out.println("队列的尾数据是:" + result);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                default:
                    break;
            }
        }
    }
}

class ArrayQueue{
    //最大容量
    private int maxSize;
    //队列头，也可以看作头指针
    private int front;
    //队列尾，也可以看作尾指针
    private int rear;
    //该数组用于模拟队列，存储数据
    private int[] arr;

    public int getMaxSize() {
        return maxSize;
    }

    public void setMaxSize(int maxSize) {
        this.maxSize = maxSize;
    }

    public int getFront() {
        return front;
    }

    public void setFront(int front) {
        this.front = front;
    }

    public int getRear() {
        return rear;
    }

    public void setRear(int rear) {
        this.rear = rear;
    }

    public ArrayQueue(){
        //默认初始化大小
        this.maxSize = 3;
        //初始化容器
        arr = new int[maxSize];
        //队列头指针分析front是指向队列头的前一个指针，没去出一个数据向前移一位
        front = -1;
        //队列尾指针，指向队列尾，没添加一个数据，向前移一位
        rear = -1;
    }

    //创建队列构造器
    public ArrayQueue(int arrayMaxSize) {
        this.maxSize = arrayMaxSize;
        //初始化容器
        arr = new int[maxSize];
        //队列头指针分析front是指向队列头的前一个指针，没去出一个数据向前移一位
        front = -1;
        //队列尾指针，指向队列尾，没添加一个数据，向前移一位
        rear = -1;
    }


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

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

    //添加元素
    public void addQueue(int n){
        if (isFull()) {
            System.out.println("队列已满不能添加数据~~");
            return;
        }
        rear++;
        arr[rear] = n;
    }

    //取出元素
    public int getQueue(){
        if (isEmpty()) {
            throw new RuntimeException("队列为空，无法继续取出数据");
        }
        return arr[front+1];
    }

    //显示所有元素
    public void showQueue(){
        if (isEmpty()) {
            System.out.println("队列为空，无法展示全部数据");
            return;
        }
        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[front+1];
    }

    //显示尾数据
    public int rearQueue(){
        if (isEmpty()) {
            throw new RuntimeException("队列为空，无法继续取出尾数据");
        }
        return arr[rear];
    }
}

这种实现有缺点，不能很好的利用数组的空间，例如我将该数组队列的所有元素取出来之后，按照常理，我们可以将新的数据放在里面，但是由于我们的指针已经指到了队列的尾部，这就会出现，当我们想要放新数据时，会出现队列已满无法添加新的元素，这就造成了空间的浪费，所以我们需要设计一种数据结构，当元素全都取出时，我们的指针可以回到头部，构建一个环形队列。

下一篇将继续介绍队列，环形队列。