数据结构——队列

利用java和环形数组实现队列

队列介绍

Ø 队列是一个有序列表，可以用 数组 或是 链表 来实现。

Ø 遵循 先入先出 的原则。即：先存入队列的数据，要先取出。后存入的要后取出

Ø 示意图： ( 使用数组模拟队列示意图 )

 

Ø 出队列操作 getQueue

Ø 显示队列的情况print_ Queue

Ø 查看队列头元素 head Queue

Ø 退出系统 exit

数组模拟环形队列

对前面的数组模拟队列的优化，充分利用数组.
因此将数组看做是一个环形的。(通过取模的方式来实现即可)

思路如下:

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 Queue {

    public static void main(String[] args) {
        ArrayQueue queue = new ArrayQueue(4);//有效存储空间为3，因为有一个空间用来做约定了
        char key = ' ';
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while (loop) {
            System.out.println("-------------------");
            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("-------------------");
            key = scanner.next().charAt(0);//接收一个字符
            switch (key) {
                case 's':
                    queue.print_Queue();
                    break;
                case 'e':
                    scanner.close();
                    System.out.println("程序退出");
                    loop = false;
                    break;
                case 'a':
                    System.out.print("输入一个数：");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = queue.getQueue();
                        System.out.println("取出数据：" + res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int res = queue.headQueue();
                        System.out.println("队列头数据：" + res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
            }
        }
    }
}
    class ArrayQueue{
        private int maxSize;
        private int front;//指向第一个元素
        private int rear;//指向最后一个元素的后一个位置
        private int[] arr;

        public ArrayQueue(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("队列已满");
                return ;
            }
            arr[rear] = n;
            rear = (rear+1)%maxSize;
        }
        public int getQueue(){
            if(isEmpty()) {
                throw new RuntimeException("队列为空，无数据");
            }
            int value = arr[front];
            front=(front+1)%maxSize;
            return value;
        }
        public void print_Queue(){
            if(isEmpty()){
                System.out.println("队列为空，无数据");
                return;
            }
            int sum = (rear + maxSize - front)%maxSize;//有效数据个数
            for(int i = front;i<front+sum;i++){
                System.out.printf("arr[%d]=%d\n",i%maxSize,arr[i%maxSize]);
            }
        }
        public int headQueue(){
            if(isEmpty()){
                throw new RuntimeException("队列为空，无数据");
            }
            return arr[front];

        }

    }