用java实现队列

2.2简单队列

对列是一种有序列表，可以通过数组或者是链表来实现。

队列遵循着先入先出的原则（FIFO）

在队列里，我们常常用front来表示队列开头的元素，rear来表示队列最后一个元素。

rear会随着输入而变化，front会随着输出而变化。

2.2.1.思路分析

当我们将数据存入队列时称为”addQueue"，addQueue的处理需要有两个步聚:思路分析

将尾指针往后移: rear+1，当front == rear 【空】

若尾指针rear小于队列的最大下标maxSize-1，则将数据存入rear所指的数组元素中，否则无法存入数据。rear == maxSize - 1[队列满]

2.2.2.代码实现

package arrqueue;

//使用数组实现
public class arrqueue {
    private int maxsize;//队列的最大长度
    private int front;//队列头
    private int rear;//队列尾
    private int[] arr;//队列

    public arrqueue(int size) {
        maxsize = size;
        arr = new int[maxsize];
        front = -1;//指向第一个元素前一个位置
        rear = -1;//指向最后一个元素

    }

    //判断是否为满
    public boolean isfull() {
        return rear == maxsize - 1;
    }

    //判断是否为空
    public boolean isempty() {
        return rear == front;

    }

    //添加数据
    public void addQueue(int n) {
        if (isfull()) {
            System.out.println("队列已经满了，无法添加了");
            return;
        }
        arr[++rear] = n;
    }

    //获取数据
    public int getQueue() {
        if (isempty()) {
            //因为有返回值，所以这里我们选择抛出异常,输出异常后就不用再return了
            throw new RuntimeException("队列空，不能获取");

        }
        return arr[++front];
    }

    //遍历
    public void showQueue() {
        if (isempty()) {
            System.out.println("队列为空");
            return;
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println("第" + i + 1 + "位:" + arr[i]);
        }

    }

    //显示此时的头数据,非获取
    public int headData() {
        if (isempty()) {
            throw new RuntimeException("队列为空---没有数据");

        }
        return arr[front + 1];
    }

}

测试类

package arrqueue;

import java.util.Scanner;

public class arrQueueTest {
    public static void main(String[] args) {
        arrqueue queue = new arrqueue(5);
        Scanner s = new Scanner(System.in);
        char key='i';//接受用户输入
        boolean bool=true;
        while (bool){


            System.out.println();
            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=s.next().charAt(0);//接受一个字符
            switch (key){
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("输入一个数");
                    int value=s.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
                        System.out.println(queue.getQueue());
                    }
                    catch (RuntimeException e){
                        //抛出异常信息
                        e.getMessage();

                    }
                    break;
                case 'h':
                    try {
                        System.out.println(queue.headData());
                    }
                    catch (RuntimeException e){
                       e.getMessage();
                    }
                    break;
                case 'e':
                    s.close();
                    bool=false;
                    break;
                default:
                    System.out.println("错误的输入");
                    break;
            }

        }
        System.out.println("程序退出。。。。");
    }
}

现在这个队列存在一个问题，当队列使用一次之后，这个队列就废了。

此时，就需要把该队列变成环形队列。

2.3.环形队列（取模法 ）

2.3.1.思路分析

思路如下:

1. front变量的含义做一个调整: front就指向队列的第一个元素,也就是说arr[front]就是队列的第一个元素front的初始值=o
2. rear变量的含义做一个调整: rear指向队列的最后一个元素的后一个位置.因为希望空出一个空间做为约定.rear的初始值=o
3. 当队列满时，条件是==(rear +1) %maxSize = front【满】==
4. 对队列为空的条件，rear == front空
5. 当我们这样分析，队列中有效的数据的个数（rear+ maxSize -front) % maxSize
6. 我们就可以在原来的队列上修改得到，一个环形队列

2.3.2.代码实现

package arrqueue;


//使用数组实现
public class circleArrQueue {
    private int maxsize;//队列的最大长度
    private int front;//队列头
    private int rear;//队列尾
    private int[] arr;//队列

    public circleArrQueue(int size) {
        maxsize = size;
        arr = new int[maxsize];
        // front = 0;
        // 指向第一个元素,默认是0可以不写
        // rear = 0;
        // 指向最后一个元素的下一位，默认是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()) {
            //因为有返回值，所以这里我们选择抛出异常,输出异常后就不用再return了
            throw new RuntimeException("队列空，不能获取");

        }
        int value = arr[front];
        front = (front + 1) % maxsize;
        return value;
    }

    //求出当前有效数据
    public int getyxvalue() {
        return (rear + maxsize - front) % maxsize;
    }

    //遍历
    public void showQueue() {
        if (isempty()) {
            System.out.println("队列为空");
            return;
        }
        System.out.println("当前队列人员位置如下:");
        for (int i = front; i < front + getyxvalue(); i++) {
            System.out.println("第" + ((i % maxsize) + 1) + "位:" + arr[i]);
        }

    }

    //显示此时的头数据,非获取
    public int headData() {
        if (isempty()) {
            throw new RuntimeException("队列为空---没有数据");

        }
        return arr[front];
    }

}

测试

package arrqueue;

import java.util.Scanner;

public class circleArrQueueTest {
    public static void main(String[] args) {
        circleArrQueue queue = new circleArrQueue(5);//设置是5，但有效序列只有4
        Scanner s = new Scanner(System.in);
        char key='i';//接受用户输入
        boolean bool=true;
        while (bool){


            System.out.println();
            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=s.next().charAt(0);//接受一个字符
            switch (key){
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("输入一个数");
                    int value=s.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
                        System.out.println(queue.getQueue());
                    }
                    catch (RuntimeException e){
                        //抛出异常信息
                        e.getMessage();

                    }
                    break;
                case 'h':
                    try {
                        System.out.println(queue.headData());
                    }
                    catch (RuntimeException e){
                        e.getMessage();
                    }
                    break;
                case 'e':
                    s.close();
                    bool=false;
                    break;
                default:
                    System.out.println("错误的输入");
                    break;
            }

        }
        System.out.println("程序退出。。。。");
    }
}