队列

①、单向队列（Queue）：只能在一端插入数据，另一端删除数据。

②、双向队列（Deque）：每一端都可以进行插入数据和删除数据操作。

1.Java模拟单向队列实现

public class MyQueue {
    private Object[] queueArray;
    private int maxSize;  //队列总大小
    private int front;   //队列前端
    private int rear;    //队列后端
    private int nItems;  //队列实际数目

    public MyQueue(int size){
         maxSize=size;
        queueArray=new Object[maxSize];
        front=0;
        rear=-1;
        nItems=0;
    }

    //查看对头数据
    public Object peekFront(){
        return queueArray[front];
    }

    //判断队列是否满了
    public boolean isFull(){
        return (nItems==maxSize);
    }

    //判断队列是否为空
    public boolean isEmpt(){
        return (nItems==0);
    }

    //返回队列的大小
    public int getSize(){
        return nItems;
    }

    //队列中新增数据
    public void insert(int value){
        if (isFull()){
            System.out.println("队列已满！");
        }else {
            if (rear==maxSize-1){
                rear=-1; //队尾元素已满，循环回来
            }
            queueArray[++rear]=value;
            nItems++;
        }
    }

    //移除数据
    public Object remove(){
        Object removeValue=null;
        if (!isEmpt()){
            removeValue=queueArray[front];
            queueArray[front]=null;
            front++;   //队头元素移除后，指针往上移动
            if (front==maxSize){
                front=0; 
            }
            nItems--;
            return removeValue;
        }
        return removeValue;
    }

}

Test：

public class MyQueueTest {
    public static void main(String[] args) {
        MyQueue queue = new MyQueue(3);
        queue.insert(5);
        queue.insert(3);
        queue.insert(8);//插入数据
        System.out.println(queue.peekFront());//对头数据
        queue.remove();      //移除数据
        System.out.println(queue.peekFront());
        queue.insert(4);
        queue.insert(0); //此时队列已满
    }
}

 

 

优先级队列 是0个或多个元素的集合，每个元素都有一个优先权，对优先级队列执行的操作有：

　　（1）查找

　　（2）插入一个新元素

　　（3）删除

public class PriQueue {
    private int maxSize;
    private int[] priQueueArray;
    private int nItems;

    public PriQueue(int size) {
        maxSize=size;
        priQueueArray=new int[maxSize];
        nItems=0;
    }

    //插入数据
    //选择的排序方法是插入排序，按照从大到小的顺序排列，越小的越在队列的顶端(下标nItem-1)
    public void insert(int value){
        int j;  //定义j是为了插入排序使用
        if (nItems==0){
            priQueueArray[nItems++]=value;
        }else {
            j=nItems-1;  //定义j为当前最小数，即插入数value的前一项
            while (j>=0&&value>priQueueArray[j]){
                priQueueArray[j+1]=priQueueArray[j];
                j--;
            }
            priQueueArray[j+1]=value;
            nItems++;
        }
    }

    //移除数据,由于是按照大小排序的，所以移除数据我们指针向下移动
    //被移除的地方由于是int类型的，不能设置为null，这里的做法是设置为 -1
    public int remove(){
        int k=nItems-1;
        int value=priQueueArray[k];
        priQueueArray[k]=-1; //-1表示这个位置的数据被移除了
        nItems--;
        return value;
    }

    //查看优先级最高的元素
    public int peekMax(){
        return priQueueArray[nItems-1];
    }

    //判断是否为空
    public boolean isEmpt(){
        return (nItems==0);
    }

    //判断是否满了
    public boolean isFull(){
        return (nItems==maxSize);
    }

}

Test：

public class PriQueueTest {
    public static void main(String[] args) {
        PriQueue priQueue = new PriQueue(5);
        priQueue.insert(15);
        priQueue.insert(26);
        priQueue.insert(18);
        priQueue.insert(3);
        priQueue.insert(32);
        System.out.println("队列是否满了？"+priQueue.isFull());

        System.out.println(priQueue.remove());
        System.out.println(priQueue.remove());
        System.out.println(priQueue.remove());
        System.out.println(priQueue.remove());
        System.out.println(priQueue.remove());

        System.out.println("队列是否满了？"+priQueue.isFull());
        System.out.println("队列是否为空？"+priQueue.isEmpt());
    }
}