学习数据结构之队列

// 一次性数组队列
public class Demo3 {
    public static void main(String[] args) {
        ArrayQueue queue = new ArrayQueue(5);
        queue.addNum(1);
        queue.addNum(2);
        queue.addNum(3);
        queue.addNum(4);
        queue.addNum(5);
        System.out.println(queue.getNum());
        queue.showQueue();
    }
}

class ArrayQueue {
    //队列的大小
    int maxSize;
    //用数组来实现队列
    int[] arr;
    //指向队列首元素的前一个位置
    int front;
    //指向队列的尾元素
    int rear;
    // 构造初始值，队列长度
    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[this.maxSize];
        //front指向队列首元素的前一个位置，初始下标为-1
        front = -1;
        rear = -1;
    }

    // 当出队的下标等于数组的长度减一时，队列满
    public boolean isFull() {
        return rear == maxSize - 1;
    }

    // 队列为空：出队与入队下标一致
    public boolean isEmpty() {
        return front == rear;
    }

    // 添加时判断对列是否已满，否，则数组下标后移赋值
    public void addNum(int num) {
        if(isFull()) {
            System.out.println("队列已满，无法在进行入队操作");
            return;
        }
        //队尾标记后移，指向要放入的元素的位置，
        rear++;
        arr[rear] = num;
    }
    // 出队判空，当前默认下标为-1.没有动过，下标递增，出队取值
    public int getNum() {
        if(isEmpty()) {
            throw new RuntimeException("队列为空，无法出队");
        }
        //队首标记后移，指向队首元素
        System.out.print("出队元素是：");
        front++;
        return arr[front];
    }

    // 简单遍历
    public void showQueue() {
        if(isEmpty()) {
            throw new RuntimeException("队列为空，无法遍历");
        }
        System.out.println("遍历队列");
        // 遍历入队元素，
        for(int start = front+1; start<=rear; start++) {
            System.out.println(arr[start]);
        }
    }
}


// 循环队列，数组重新利用
public class Demo4 {
    public static void main(String[] args) {
        ArrayAroundQueue aroundQueue = new ArrayAroundQueue(5);
        aroundQueue.addNum(1);
        aroundQueue.addNum(2);
        aroundQueue.addNum(3);
        aroundQueue.addNum(4);
        aroundQueue.showQueue();
        System.out.println(aroundQueue.getNum());
        System.out.println(aroundQueue.getNum());
        aroundQueue.addNum(5);
        aroundQueue.addNum(6);
        aroundQueue.showQueue();
        aroundQueue.getHead();

    }
}

class ArrayAroundQueue {
    //队列的大小
    int maxSize;
    //用数组来实现队列
    int[] arr;
    //指向队列首元素的前一个位置
    int front;
    //指向队列的尾元素
    int rear;

    // 初始化数组队列
    public ArrayAroundQueue(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[this.maxSize];
        //front ，rear，初始下标值
        front = 0;
        rear = 0;
    }


    def boolean isFull() {
        // 当入队达到最大下标，出队为0，说明第一次队列已满，重新添加元素
        return (rear+1)%maxSize == front;
    }


    public boolean isEmpty() {
        return front == rear;
    }


    public void addNum(int num) {
        if(isFull()) {
            System.out.println("队列已满，无法在进行入队操作");
            return;
        }
        //先放入元素，在后移队尾标记
        arr[rear] = num;
        // 入队指针移动：当入队达到下标最大值时，rear为0，此时，又一轮队列开始
        rear = (rear+1)%maxSize;
    }

    public int getNum() {
        if(isEmpty()) {
            throw new RuntimeException("队列为空，无法出队");
        }
        //队首标记后移，指向队首元素
        System.out.print("出队元素是：");
        // front元素，初始值0，返回元素，同时出队指针移动
        int num = arr[front];
        // 一轮新的下标开始，下标轮回
        front = (front+1)%maxSize;
        return num;
    }

    public void showQueue() {
        if(isEmpty()) {
            throw new RuntimeException("队列为空，无法遍历");
        }
        System.out.println("遍历队列");
        //当front + 1 == rear时停止遍历，原因是：？
        int start = front;
        while(start != rear) {
            System.out.println(arr[start]);
            //移动到下一个元素，当数组为10时，下标为9时队列满，下一次队列的下标为0，，当未满时，按余数走
            start = (start+1)%maxSize;
        }
    }

    public void getHead() {
        if(isEmpty()) {
            throw new RuntimeException("队列为空");
        }

        System.out.println("队首元素为："+arr[front]);
    }
}