队列

       队列，顾名思义，就是好像我们过年去售票处买票，大家有秩序的排成一列，谁先到，谁就排在前面，就先买到票离开。即先进先出（FIFO）原则。队列可以看成打通栈的栈底，继而从栈的先进后出，变为队列的先进先出。像我现在写这篇博客，先输入的文字在前面，后输入的文字在后面一样。
       下面用数组实现队列：

public class Quene {
    private int maxSize;
    private long[] arrayQuene;
    private int front;
    private int rear;
    private int nums;
    public Quene(int s){
        maxSize = s;
        arrayQuene = new long[s];
        front = 0;
        rear = -1;
        nums = 0;
    }
    public void insert(long value){
        if(rear==maxSize-1)
            rear = -1;
        arrayQuene[++rear] = value;
        nums++;
    }
    public long delete(){
        long temp = arrayQuene[front++];
        if(front==maxSize)
            front = 0;
        nums--;
        return temp;
    }
    public int getSize(){
        return nums;
    }
    public long peekFront(){
        return arrayQuene[front];
    }
    public boolean isEmpty(){
        return nums == 0;
    }
    public boolean isFull(){
        return nums == maxSize;
    }
    public static void main(String[] args) {
        Quene quene = new Quene(10);
        quene.insert(1);
        quene.insert(2);
        quene.insert(3);
        quene.insert(4);
        quene.insert(5);
        System.out.println("队首元素为："+quene.peekFront());
        System.out.println("删除："+quene.delete());
        System.out.println("删除："+quene.delete());
        System.out.println("队首元素为："+quene.peekFront());
        quene.insert(6);
        quene.insert(7);
        quene.insert(8);
        while(!quene.isEmpty()){
            System.out.println("删除："+quene.delete());
        }
    }
}

运行结果为：

队首元素为：1
删除：1
删除：2
队首元素为：3
删除：3
删除：4
删除：5
删除：6
删除：7
删除：8

       上面的程序使用nums来记录队列中元素的数量，队列空或者队列满也是使用nums。其实我们也可以不使用额外的这个nums来记录，而是让数组的容量比队列的长度大1（rear到达队列尾部，再插入元素是就会变为0，这是rear比front小，队列为空或满时front和rear在同一位置。）
       下面的程序不使用nums计数：

public class Quene {
    private int maxSize;
    private long[] arrayQuene;
    private int front;
    private int rear;
    public Quene(int s){
        maxSize = s;
        arrayQuene = new long[s];
        front = 0;
        rear = -1;
    }
    public void insert(long value){
        if(rear==maxSize-1)
            rear = -1;
        arrayQuene[++rear] = value;
    }
    public long delete(){
        long temp = arrayQuene[front++];
        if(front==maxSize)
            front = 0;
        return temp;
    }
    public int getSize(){
        if(rear>=front){
            return rear-front+1;
        }else{
            return (maxSize-front) + (rear+1);
        }
    }
    public long peekFront(){
        return arrayQuene[front];
    }
    public boolean isEmpty(){
        return (rear+1==front || (front+maxSize-1==rear));
    }
    public boolean isFull(){
        return (rear+2==front || (front+maxSize-2==rear));
    }
    public static void main(String[] args) {
        Quene quene = new Quene(10);
        quene.insert(1);
        quene.insert(2);
        quene.insert(3);
        quene.insert(4);
        quene.insert(5);
        System.out.println("队首元素为："+quene.peekFront());
        System.out.println("删除："+quene.delete());
        System.out.println("删除："+quene.delete());
        System.out.println("队首元素为："+quene.peekFront());
        quene.insert(6);
        quene.insert(7);
        quene.insert(8);
        while(!quene.isEmpty()){
            System.out.println("删除："+quene.delete());
        }
    }
}

运行结果为：

队首元素为：1
删除：1
删除：2
队首元素为：3
删除：3
删除：4
删除：5
删除：6
删除：7
删除：8

       两段程序的运行结果相同，说明实现效果是一样的。

       优先级队列，就是按照元素的优先级，插入到队列的相应位置中，优先级高的先执行，例如多任务操作系统就使用优先级队列。生活中，比如邮件框里的邮件，最紧急的放在最上方，最不紧急的放在最下方，这样就可以按照紧急的程度来处理邮件，下面我们使用数组来实现优先级队列（当然优先级队列通常用堆来实现），这个例子中数值越小下标越大。

public class PriorityQuene {
    private int maxSize;
    private long[] arrayQuene;
    private int nItems;
    public PriorityQuene(int s){
        maxSize = s;
        arrayQuene = new long[maxSize];
        nItems = 0;
    }
    public long peekMin(){
        return arrayQuene[nItems-1];
    }
    public boolean isEmpty(){
        return (nItems == 0);
    }
    public boolean isFull(){
        return (nItems == maxSize);
    }
    public void insert(long value){
            int i = 0;
            if(nItems==0){
                arrayQuene[nItems++] = value;
            }else{
                for(i=nItems-1;i>=0;i--){
                    if(value>arrayQuene[i]){
                        arrayQuene[i+1] = arrayQuene[i];
                    }else{
                        break;
                    }
                }
                arrayQuene[i+1] = value;
                nItems++;
            }
    }
    public long remove(){
            return arrayQuene[--nItems];
    }
    public static void main(String[] args) {
        PriorityQuene pq = new PriorityQuene(10);
        pq.insert(3);
        pq.insert(5);
        pq.insert(1);
        pq.insert(2);
        pq.insert(4);
        while(!pq.isEmpty()){
            System.out.println("删除元素： "+pq.remove());
        }
    }
}

运行结果为：

删除元素： 1
删除元素： 2
删除元素： 3
删除元素： 4
删除元素： 5