数据结构与算法之队列

队列

队列介绍
1.队列是一个有序列表，可以用数组或是链表来实现。
2.遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出
3.示意图：

数组模拟队列
当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤：思路分析
1.将尾指针往后移：rear+1 , 当front == rear 【空】
2.若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear所指的数组元素中，否则无法存入数据。 rear == maxSize - 1[队列满]

代码实现：

class queue{
    private int[] arr;
    private int MaxSize;//队列的大小
    private int front;//队首指针
    private int rear;//对尾指针
    public queue(int arrSize){
        MaxSize=arrSize;
        arr=new int[MaxSize];
        front=-1;
        rear=-1;
    }
    //判断是否对满
    public boolean isFull(){
        return MaxSize-1==rear;
    }
    //判断是否队空
    public boolean isEmpty(){
       return rear==front;
    }
    //入队
    public void addQueue(int n){
        if (isFull()){
            throw new RuntimeException("队已满");
        }
        rear++;
        arr[rear]=n;
    }
    //出队
    public int getQueue(){
        if (isEmpty()){
            throw  new RuntimeException("队已空");
        }
        front++;
        return arr[front];
    }
    //队列的遍历
    public void showQueue(){
        if (isEmpty()){
            return;
        }
        for (int i=0;i<arr.length;i++){
            System.out.println(i+" "+arr[i]);
        }
    }
    //遍历队列中存在的元素
    public void show(){
        if (isEmpty()){
            return;
        }
        System.out.println(front+" "+rear);
        for (int i=front+1;i<=rear;i++){
            System.out.println(arr[i]);
        }
    }
    //取头节点的数据
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("队为空,没有数据");
        }
        return arr[front+1];
    }

}


public class ArrayQueue {

    private static queue queue;

    public static void main(String[] args) {
        queue = new queue(5);
        for (int i=0;i<5;i++){
            queue.addQueue(i);
        }
        queue.showQueue();
        System.out.println(  queue.getQueue());
        System.out.println(queue.getQueue());
        System.out.println("--------------");
        queue.showQueue();
        System.out.println("--------------");
        queue.show();
        queue.addQueue(8);

    }
}

问题分析和性能优化：
1.目前数组使用一次就不能用了，没有达到复用效果
2.将数组使用算法改进成一个环形队列 取模：%

循环队列
1.判断队满的条件：(rear+1)%MaxSize==front
2.判断队列中实际有效的个数：(rear+MaxSize-front)%MaxSize

解决实现一个环形队列：

class Circlequeue{
    private int[] arr;
    private int MaxSize;//队列的大小
    private int front;//队首指针
    private int rear;//对尾指针
    public Circlequeue(int arrSize){
        MaxSize=arrSize;
        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()){
            throw new RuntimeException("队已满");
        }
        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 show(){
        if (isEmpty()){
            return;
        }
        System.out.println(front+" "+rear);
        for (int i=front;i<front+size();i++){
            System.out.println(arr[i]);
        }
    }
    //取头节点的数据,显示队头数据
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("队为空,没有数据");
        }
        return arr[front];
    }
    //返回队列中实际有效的个数
    public int size(){
        return (rear+MaxSize-front)%MaxSize;
    }

}


public static void main(String[] args) {
        Circlequeue queue = new Circlequeue(3);
        queue.addQueue(10);
        queue.show();
        queue.addQueue(20);
        queue.show();
        queue.getQueue();
        queue.addQueue(30);
        queue.show();


    }