数据结构与算法-队列（2）

数据结构与算法-队列（2）

提要：需在数据结构与算法-队列（1） 解队列特点，以及数组实现队列的主要要素，本文主要是在队列（1）基础上进行调整，实现循环队列

用数组实现环形队列思路：

1. front 变量的含义调整：front就指向队列的第一个元素
2. rear变量的含义调整：rear指向队列的最后一个元素的后一个位置因为希望空出一个空间作为约定rear的初始值为0
3. 队列已满的条件为 （rear + 1）%maxsize = front
4. 队列为空的条件 rear == front
5. 队列中有效数据的个数（rear + maxsize -front）%maxsize

代码实例：

	```
	/**
	 * @Author by lc
	 * @Date 2020/11/5 0005 14:15
	 * @Version 1.0
	 * <p>
	 * 队列支持循环使用
	 */
	public class QueueArrayDemo2 {
	    public static void main(String[] args) throws Exception {
	
	        //创建一个队列
	        QueueArray2 queueArray = new QueueArray2(3);
	
	        char key = ' ';//接收用户输入
	
	        Scanner scanner = new Scanner(System.in);
	        while (true) {
	            System.out.println("s(show):显示队列\t\n" +
	                    "e(exit):退出程序\t\n" +
	                    "a(add):添加数据到队列\t\n" +
	                    "g(get)：从队列中取出一个数据\t\n" +
	                    "p(peek):查看队列头部元素\t\n");
	            key = scanner.next().charAt(0);
	            switch (key) {
	                case 's':
	                    queueArray.showQueue();
	                    break;
	                case 'a':
	                    System.out.println("请输入一个数");
	                    int value = scanner.nextInt();
	                    queueArray.addQueue(value);
	                    break;
	                case 'g':
	                    System.out.println(queueArray.getQueue() + "");
	                    break;
	                case 'p':
	                    System.out.println(queueArray.peek());
	                    break;
	                case 'e':
	                    System.out.println("退出程序");
	                    break;
	            }
	        }
	    }
	}
	
	//使用数组实现一个队列
	class QueueArray2 {
	    private int maxsize;//仅表示数组长度 队列的最大容量==数组长度-1
	    private int front;//队列头 出队时会变动(队列第一个元素的下标)
	    private int rear;//队列尾  入队时会变动(就是队列最后一个元素后一个位置的下标)
	    private int[] arr;//用于存储数据模拟队列
	
	    //构造方法初始化 队列
	    public QueueArray2(int maxsize) {
	        this.maxsize = maxsize;
	        arr = new int[maxsize];
	    }
	
	    //获取队列当前 实际存储数据个数
	    public int getSize() {
	        return (rear + maxsize - front) % maxsize;
	    }
	
	    //判断队列是否为空
	    public boolean isEmpty() {
	        return front == rear;
	    }
	
	    //判断队列是否已满
	    public boolean isFull() {
	        //为什么通过取模来判断 是因为考虑 尾元素 rear 可能跑在了头元素 front前面
	        //%  就是取余数 比如 5%2 就是 5除2 商2 余1  所以5%2 == 1
	        if ((rear + 1) % maxsize == front) {
	            return true;
	        }
	        return false;
	    }
	
	    //入队操作
	    public void addQueue(int num) {
	        //校验队列是否已满
	        if (isFull()) {
	            System.out.println("队列已满，不允许入队操作");
	        } else {
	            //因为rear 指向队列最后一个元素的下一个位置 所以直接赋值即可
	            arr[rear] = num;
	            //将rear后移，这个时候rear 可能已经在数组尾部，再次移动需要移动到数组头部 所以不能光 +1
	            rear = (rear + 1) % maxsize;
	        }
	    }
	
	    //出队操作
	    public int getQueue() throws Exception {
	        if (isEmpty()) {
	            throw new Exception("队列为空，暂无数据可取");
	        }
	        int value = arr[front];
	        front = (front + 1) % maxsize;
	        return value;
	    }
	
	    //展示队列 所有数据
	    public void showQueue() {
	        //遍历
	        if (isEmpty()) {
	            System.out.println("队列为空");
	            return;
	        }
	        for (int i = front; i < front + getSize(); i++) {
	            System.out.printf("arr[%d]=%d\n", i % maxsize, arr[i % maxsize]);
	        }
	    }
	
	    //查看队列头数据
	    public int peek() throws Exception {
	        if (isEmpty()) {
	            throw new Exception("队列为空，暂无数据可取");
	        }
	        return arr[front];
	    }
	}
	```