2.1-队列-基于数组实现队列

2.1-队列-基于数组实现队列

1. 队列介绍
   1. 操作受限的线性表,线性表是指队列中的元素之间的逻辑关系是一对一的,而操作受限是指,他只允许一端入,另一端出,所以也可以说是先进先出,这和栈是不同的
   2. 队列是一个有序列表,可以用数组或者是链表来实现
2. 数组模拟队列分析和实现
   1. 队列本身是有序列表,使用数组来存储队列的数据,则需要2个值记录下标(从0开始)
      1. MaxSize 该队列最大容量
      2. front–>队首
      3. rear–>队尾
   2. front和rear初始值都为-1,当添加元素的时候,rear+1,当有元素出队的时候,front+1
   3. 入队操作(addQueue):
      1. 当数组为空(rear=front)或数组没满(rear+1!=MaxSize)的时候,可以入队,令rear++

class ArrayQueue {
    private int MaxSize;//表示数组最大容量
    private int front;//指向队首
    private int rear;//指向队尾
    private int[] arr;//该数组存放数据

    //创建队列的构造器
    public ArrayQueue(int maxSize) {
        MaxSize = maxSize;
        arr = new int[MaxSize];
        //队首指针和队尾指针初始为-1
        rear = -1;//队尾指针指向队列最后一个元素
        front = -1;//队首指针指向队列第一个元素的前一个位置,也就是说,队首指针始终指向null
    }

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

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

    //添加数据到队列
    public void addQueue(int i) {
        if (!this.isFull()) {
            arr[++rear] = i;
        } else {
            System.out.println("queue is full,can not add element");
        }
    }

    //出队
    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空,不能取数据");
        }
        return arr[++front];
    }

    //显示队列的头数据
    public int headQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空");
        }
        return arr[front + 1];
    }

    //显示队列所有数据,要显示的是front+1到rear之间的数据
    public void printQueue() {
        if (isEmpty()) {
            System.out.println("队列为空");
            return;
        }
        for (int i = front + 1; i <= rear; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }

}

3. 数组模拟环形队列分析和实现
   1. 之前案例的问题:
      1. 之前的普通队列中存在问题,就是空间的浪费,rear和front都是单向运动的,所以当rear和front移动之后,那么之前的位置哪怕为空,也无法被利用了,数组使用一次就不可以使用了,没有达到复用的效果
      2. 使用算法,将数组改造为环形的数组 %
   2. 分析环形队列
      1. front变量的含义做一个调整:指向队首元素,初始值为 0
      2. rear变量含义做一个调整:指向队尾元素的后一个元素 初始值为 0,至于初始值为什么为0,因为是环形的队列,也就是把数组首尾相连,这个时候自然没有-1的位置了
      3. 那么当 (rear+1) % MaxSize = front的时候,队列满
      4. 那么当rear = front的时候,队列空
      5. 这个时候,队列中会存在一个单位的空间浪费
      6. 队列中数据的个数:(rear + MaxSize - front) % MaxSize

package com.hejiale.queue.v2;

import java.util.Scanner;

/**
 * 使用数组模拟环形队列,环形队列存在空间的浪费,但是可以实现一个数组多次复用
 */
public class ArrayQueueDemo {
    public static void main(String[] args) {
        ArrayQueue arrayQueue = new ArrayQueue(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':
                    arrayQueue.printQueue();
                    break;
                case 'a':
                    System.out.println("请输入一个数字");
                    int i = scanner.nextInt();
                    arrayQueue.addQueue(i);
                    break;
                case 'g':
                    try {
                        System.out.println("取出的数据是:" + arrayQueue.getQueue());
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        System.out.println("队首数据是:" + arrayQueue.headQueue());
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
            System.out.println("----------------------");
        }
        System.out.println("程序退出");
    }
}

class ArrayQueue {
    private int MaxSize;//表示数组最大容量
    private int front;//指向队首
    private int rear;//指向队尾
    private int[] arr;//该数组存放数据

    /**
     * 创建队列的构造器
     *
     * @param size 容器的大小
     *             注意:因为环形队列中,rear始终指向空,且从0开始,所以环形队列会存在一个空间的浪费,也就是说,如果用户创建的
     *             容器想存放size个数据,则MaxSize = size + 1;
     */
    public ArrayQueue(int size) {
        MaxSize = size + 1;
        arr = new int[MaxSize];
        //队首指针和队尾指针初始为0,注意这个和非环形队列初始化的区别
        rear = 0;//队尾指针指向队尾元素的后一个位置,也就是说,rear指针永远指向null
        front = 0;//队首指针指向队首元素
    }

    //判断队列是否满--和非环形队列判满方式不同
    public boolean isFull() {
        return (rear + 1) % MaxSize == front;
    }

    //判断队列是否为空--和非环形队列判空方式不同
    public boolean isEmpty() {
        return rear == front;
    }

    //添加数据到队列--和非环形队列添加方式不同,因为rear指向的是队尾元素的后一个元素null,所以应该先赋值,再(rear + 1) % MaxSize
    public void addQueue(int i) {
        if (!this.isFull()) {
            arr[rear] = i;
            rear = (rear + 1) % MaxSize;
        } else {
            System.out.println("queue is full,can not add element");
        }
    }

    //出队--和非环形队列出队方式不同,因为front指向的是队首元素,所以应该先输出数据,再(front + 1) % MaxSize
    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空,不能取数据");
        }
        int i = arr[front];
        front = (front + 1) % MaxSize;
        return i;
    }

    //显示队列的头数据--和非环形队列方式不同,因为front指向的就是队首元素,所以不用+1;直接输出就好
    public int headQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空");
        }
        return arr[front];
    }

    //显示队列所有数据
    public void printQueue() {
        if (isEmpty()) {
            System.out.println("队列为空");
            return;
        }
        /*
         遍历输出和非环形队列不一样,因为非环形队列中,rear肯定大于等于front,所以我们可以直接输出两者之间的数据,
         但是环形队列不一样,rear可能在取模后会小于front,所以我们不可以直接输出rear到front之间的数据,
         正确的方式应该是,通过(rear + MaxSize - front),知道队列中有几个数据,然后就从front开始,输出几个数据即可
         但是注意,我们知道应该输出几个数据之后,我们每次移动j的时候,记得取模而不是简单++
         */
        for (int i = 1, j = front; i <= size(); i++) {
            System.out.print(arr[j] + "\t");
            j = (j + 1) % MaxSize;
        }
        System.out.println();
    }

    //返回环形队列中数据的个数
    public int size(){
        return (rear + MaxSize - front) % MaxSize;
    }

}