队列-java语言描述

队列

1、单向队列

1.1、概念

​ 是一种先入后出的有序列表

1.2、实现的思路

/* 
定义一个数组
maxsize：该队列的最大容量
front：队列的前端（不含最前元素），随数据的输入而改变，初始值为 -1
rear：队列的后端（含最后元素），随数据的输出而改变，初始值为 -1
1、将尾指针往后移，rear+1，当 front=rear为空
2、若尾指针 rear小于队列的最大下标 maxsize-1，则将数据存入到 rear所指的数组元素中，否则无法存入数据，rear=maxsize-1为队列满
*/

1.3、实现

public class ArrayQueueDemo {
    public static void main(String[] args) {
        ArrayQueue array = new ArrayQueue(5);
        Scanner input = new Scanner(System.in);
        char key = ' ';
        boolean flag = true;
        while (flag) {
            System.out.println("s，为显示队列");
            System.out.println("a，为添加队列");
            System.out.println("g，为获取队列");
            System.out.println("f，为获取队列头部");
            System.out.println("e，退出");
            key = input.next().charAt(0);
            switch (key) {
                case 's':
                    array.showQueue();
                    break;
                case 'a':
                    System.out.println("请输入你要添加的值：");
                    int num = input.nextInt();
                    array.addQueue(num);
                    break;
                case 'g':
                    try {
                        int number = array.getQueue();
                        System.out.println("取出的数据是：" + number);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'f':
                    try {
                        array.showFront();
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    System.out.println("程序退出！");
                    input.close();
                    flag = false;
                    break;
                default:
                    break;
            }
        }
    }
}

class ArrayQueue {
    private int maxSize;    //表示数组的最大容量
    private int[] array;    //该数组用于存放数据，模拟队列
    private int front;      //队列头
    private int rear;       //队列尾

    public ArrayQueue(int arrMaxSize) {
        maxSize = arrMaxSize;
        array = new int[maxSize];
        front = -1; //指向队列头部，分析出front是指向队列头部的前一个位置
        rear = -1;  //指向队列尾部，指向队列尾的最后一个数据（即就是队列的最后一个位置）
    }

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

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

    //增加一个数据
    public void addQueue(int num) {
        if (isFull()) {
            System.out.println("队列已满，不能在添加数据！");
            return;
        }
        array[++rear] = num;
    }

    //获取一个数据
    public int getQueue() {
        if (isEmpty()) {
            //抛出异常来提示
            throw new RuntimeException("队列为空，不能获取数据！");
        }
        return array[++front];
    }

    //显示队列的所有数据
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列为空，没有数据！");
        } else {
            for (int i = front + 1; i < array.length; i++) {
                System.out.print(array[i] + " ");
            }
            System.out.println();
        }
    }

    //显示队列的头数据
    public void showFront() {
        if (isEmpty()) {
            System.out.println("队列为空，没有数据！");
        } else {
            System.out.println("队列的头数据：" + array[front + 1]);
        }
    }
}

1.4、小结

/*
注意：
这个时候的队列只是一个单项顺序队列，当你将数组存满之后，在删除一个元素，并不能再次添加元素到队列之中
*/

2、循环队列

2.1、概念

​ 还是一种先入后出的有序列表，不过是一个环形的有序列表

2.2、实现的思路

/*
定义一个数组
maxsize：该队列的最大容量
front：队列的前端（含最前元素），随数据的输入而改变，初始值为 0
rear：队列的后端（含最后元素），随数据的输出而改变，初始值为 0
1、将尾指针往后移，rear+1，
2、若尾指针 rear小于队列的最大下标 maxsize-1，则将数据存入到 rear所指的数组元素中，否则无法存入数据，
3、当 front=rear为空
4、当 (rear+1)%maxSize = front为队列满
5、队列中的有效个数：(rear+maxSize-front)%maxSize //rear=-1  front=0
*/

2.3、实现

public class CircleArrayQueueDemo {
    public static void main(String[] args) {
        CircleArray array = new CircleArray(5);
        Scanner input = new Scanner(System.in);
        char key = ' ';
        boolean flag = true;
        while (flag) {
            System.out.println("s，为显示队列");
            System.out.println("a，为添加队列");
            System.out.println("g，为获取队列");
            System.out.println("f，为获取队列头部");
            System.out.println("e，退出");
            key = input.next().charAt(0);
            switch (key) {
                case 's':
                    array.showQueue();
                    break;
                case 'a':
                    System.out.println("请输入你要添加的值：");
                    int num = input.nextInt();
                    array.addQueue(num);
                    break;
                case 'g':
                    try {
                        int number = array.getQueue();
                        System.out.println("取出的数据是：" + number);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'f':
                    try {
                        array.showFront();
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    System.out.println("程序退出！");
                    input.close();
                    flag = false;
                    break;
                default:
                    break;
            }
        }
    }
}

class CircleArray{
    private int maxSize;    //表示数组的最大容量
    private int[] array;    //该数组用于存放数据，模拟队列
    private int front;      //队列头
    private int rear;       //队列尾

    public CircleArray(int arrMaxSize){
        maxSize = arrMaxSize;
        array = new int[maxSize];
        front = 0;  //front就指向队列的第一个元素
        rear = 0;   //rear指向队列的最后一个元素的后一个元素，因为希望空出一个位置
    }

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

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

    //增加一个数据
    public void addQueue(int num) {
        if (isFull()) {
            System.out.println("队列已满，不能在添加数据！");
            return;
        }
        array[rear] = num;
        //将rear后移，考虑取模
        rear = (rear + 1) % maxSize;
    }

    //获取一个数据
    public int getQueue() {
        if (isEmpty()) {
            //抛出异常来提示
            throw new RuntimeException("队列为空，不能获取数据！");
        }
        /**
         * 这里需要分析出front是指向队列的第一个元素
         * 1、先把front的值存在一个临时变量
         * 2、将front后移，考虑取模
         * 3、将临时变量返回
         */
        int value = array[front];
        front = (front + 1) % maxSize;
        return value;
    }

    //求有效数据的个数
    public int size(){
        return (rear + maxSize - front) % maxSize;
    }

    //显示队列的所有数据
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列为空，没有数据！");
        } else {
            for (int i = front; i < front + size(); i++) {
                System.out.print(array[i] + " ");
            }
            System.out.println();
        }
    }

    //显示队列的头数据
    public void showFront() {
        if (isEmpty()) {
            System.out.println("队列为空，没有数据！");
        } else {
            System.out.println("队列的头数据：" + array[front]);
        }
    }
}

2.4、小结

/*
注意：
1、队列之中的有效个数是数组大小在减去 1
2、并且队列满与空的条件与单向相比改变了
	front=rear 为空
	(rear+1)%maxSize = front 为满
*/