数组结构之队列（java实现）

如何理解队列：

        我们可以把队列形象的看做一个银行柜台排队，先到的先办理业务，后到的后办理，而队列是先进先出（就好比银行先到的先办理业务，办完业务先出银行）。

队列介绍：

1. 队列是一个有序列表，可以用数组或是链表来实现。
2. 遵循先入先出的原则，

数组模拟队列思路：

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

如图所示：

• 当我们将数据存入队列时称为”addQueue”，addQueue的处理需要有两个步骤：思路分析

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

初代队列代码实现：

public class Queue {
    public static void main(String[] args) {
        ArrayQueue arrayQueue = new ArrayQueue(4);
        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':
                    arrayQueue.show();
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                case 'a':
                    System.out.println("请输入要添加的数据：");
                    int value = scanner.nextInt();
                    arrayQueue.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = arrayQueue.getQueue();
                        System.out.println(res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int head = arrayQueue.headQueue();
                        System.out.printf("队列头的数据为：%d", head);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出————");
    }
}

class ArrayQueue {
    private int maxsize;//数组最大容量
    private int front;//队列头
    private int rear;//队列尾
    private int[] arr;//该数组用于存储数据

    public ArrayQueue(int arrmaxsize) {
        this.maxsize = arrmaxsize;
        arr = new int[maxsize];
        this.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("Queue is full!");
            return;
        }
        rear++;
        arr[rear] = n;
    }

    //获取队列数据
    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty!");
        }
        front++;
        return arr[front];
    }

    public void show() {
        if (isEmpty()) {
            System.out.println("Queue is empty!");
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d]=%d\n", i, arr[i]);
        }
    }

    public int headQueue() {
        if (isEmpty()) {
            System.out.println("Queue is empty");
            throw new RuntimeException("queue is empty!");
        }
        return arr[front + 1];
    }
}

问题分析并优化：

1. 目前上边代码中的数组只能使用一次，不能复用。原因：控制角标的指针rear和front，增大后无法自动变小
2. 解决方法：将原来代码使用算法改进成环形队列 取模：%。通过取模解决了指针rear和front变大后变小

 注意：这里的环形数组，最后一个是空的，因为我们希望空出一个空间作为约定。即我们定义的数组容量为n呢么我们就只能存进去n-1个数据。最后一个空间是约定。

环形数组环形体现在哪里：

 在上图中的第五点：（rear+maxsize-front）%maxsize相当于对（rear-front）的值取了绝对值。

而环形数组这个环形体现在下图：

 这样rear和front的取值永远是在几个值之间重复。自然也就体现到了环形数组—>重复利用。

最终代码实现：

public class CircleArrayQueue {
    public static void main(String[] args) {
        CircleArr circleArre = new CircleArr(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':
                    circleArre.show();
                    break;
                case 'e':
                    scanner.close();
                    System.out.println("程序退出————");
                    break;
                case 'a':
                    System.out.println("请输入要添加的数据：");
                    int value = scanner.nextInt();
                    circleArre.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = circleArre.getQueue();
                        System.out.println(res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int head = circleArre.headQueue();
                        System.out.printf("队列头的数据为：%d", head);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    break;
            }
        }
    }
}

class CircleArr {
    private int maxsize;//数组最大容量
    private int front;//队列头
    private int rear;//队列尾
    private int[] arr;//该数组用于存储数据

    public CircleArr(int arrmaxsize) {
        maxsize = arrmaxsize;
        arr = new int[maxsize];
        //front默认值为0————指向队列头部，含第一个数据
        //rear默认值为0————指向队列尾部，最后一个数据后面，不含最后一个数据
    }

    //判断数组是非已满
    public boolean isFull() {
        return (rear + 1) % maxsize == front;
    }

    //判断数组是非为空
    public boolean isEmpty() {
        return rear == front;
    }

    //添加数据到队列
    public void addQueue(int n) {
        if (isFull()) {
            System.out.println("Queue is full!");
            return;
        }
        arr[rear] = n;
        rear = (rear + 1) % maxsize;
    }

    //获取队列数据
    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty!");
        }
//            return arr[front];这样指针就没有办法后移了。因为return，
            /*
            1,定义一个value值来记录front的值
            2,防止角标越界，采用取模的方式。
             */
        int value = arr[front];
        front = (front + 1) % maxsize;
        return value;
    }

    public int getArrsize() {
        return (rear + maxsize - front) % maxsize;
    }

    public void show() {
        if (isEmpty()) {
            System.out.println("Queue is empty!");
            return;
        }
//            for (int i = 0; i < arr.length; i++) {
//                System.out.printf("arr[%d]=%d\n",i,arr[i]);
//            }因为数组的大小会改变，所以不能用arr.length，我们定义一个方法获取数组大小。
        for (int i = front; i < front + getArrsize(); i++) {
//                System.out.printf("arr[%d]=%d\n",i,arr[i]);不能使用i，会出现角标越界，
//                例如：maxsize=4，front=1，getarrsize=4,呢么i是可以取到4的，然而数组中最大索引为3，角标越界！
            System.out.printf("arr[%d]=%d\n", i % maxsize, arr[i % maxsize]);
        }
    }

    public int headQueue() {
        if (isEmpty()) {
            System.out.println("Queue is empty");
            throw new RuntimeException("queue is empty!");
        }
        return arr[front];
    }
}