数据结构02--队列

队列是一种基于先进先出(FIFO)策略的集合类型，只允许在其一端（队尾）进行插入操作，在另一端（对头）进行删除操作。

抽象数据类型

public class Queue<Item> implements Iterable<Item>

队列API	功能
void enQueue(Item item)	添加元素(入队)
Item deQueue()	删除元素(出队)
boolean isEmpty()	判断队列是否为空
int size()	队列的大小

队列的创建

数组实现

其存储结构如下图：

数组实现队列的过程：

假设开始时数组长度为5，如图，当f入队时，此时数组末尾元素已被占用，如果继续向后就会产生下标越界，但此时数组未满，将从头开始入队。这种逻辑上首尾相连的顺序存储结构叫循环队列。当数组满（h入队）时，将数组的长度加倍。
代码如下：

import java.util.Iterator;
/**
 * 能动态调整数组大小的循环队列
 * @author Gain
 */
public class CycleArrayQueue<Item> implements Iterable<Item> {
        private int N;//记录队列大小
        //last表示尾元素后一个的索引
        private int first,last;//first表示头元素的索引
        private Item[] a;
        public CycleArrayQueue() {
            a = (Item[])new Object[1];
        }

        public int size() {return N;}
        public boolean isEmpty(){return N==0;}
        //调整数组大小
        public void resizingArray(int num) {
            Item[] temp = (Item[])new Object[num];
            for(int i=0;i<N;i++) {
                temp[i] = a[(first+i)%a.length];
            }
            a = temp;
            first = 0;//数组调整后first，last位置
            last =  N;
        }
        public void enQueue(Item item){
            //当队列满时，数组长度加倍
            if(N==a.length) resizingArray(2*N);
            a[last] = item;
            last = (last+1)%a.length;//【关键】
            N++;
        }

        public Item deQueue() {
            if(isEmpty()) return null;
            Item item = a[first];
            first = (first+1)%a.length;//【关键】
            N--;
            //当队列长度小于数组1/4时，数组长度减半
            if(N>0 && N<a.length/4) resizingArray(2*N);
            return item;
        }
        //实现迭代器
        public Iterator<Item> iterator() {
            return new ResizingArrayQueueIterator();
        }
        private class ResizingArrayQueueIterator implements Iterator<Item> {
            private int num=N;
            private int current = first;
            public boolean hasNext() {
                return num>0;
            }
            public Item next() {
                Item item = a[current++];
                num--;
                return item;
            }
        }
}

链表实现

存储结构如下图：

代码如下：

import java.util.Iterator;
/**
 * 链表实现的队列
 * @author Gain
 */
public class LinkedQueue<Item> implements Iterable<Item> {
    private Node first,last;//头结点，尾结点
    private int N=0;//队列大小
    //定义结点
    private class Node {
        Item item;
        Node next;
    }

    public int size() {return N;}
    public boolean isEmpty(){return N==0;}
    //入队
    public void enQueue(Item item) {
        Node oldLast = last;
        last = new Node();
        last.item = item;
        if(isEmpty()) {
            first = last;//【要点】
        }else {
            oldLast.next = last;
        }
        N++;
    }
    //出队
    public Item deQueue() {
        Item item = first.item;
        first = first.next;
        N--;
        if(isEmpty()) last = null;//【要点】
        return item;
    }
    //实现迭代器
    public Iterator<Item> iterator() {
        return new LinkedQueueIterator();
    }
    private class LinkedQueueIterator implements Iterator<Item>{
        private Node current = first;
        public boolean hasNext() {
            return current != null;
        }
        public Item next(){
            Item item = current.item;
            current = current.next;
            return item;
        }
    }
}

测试

代码如下：

    //测试
    public class Test {
        public static void main(String[] args) {
            int[] a = {1,2,4,6,new Integer(10),5};
            CycleArrayQueue<Integer> queue1 = new CycleArrayQueue<Integer>();
            LinkedQueue<Integer> queue2 = new LinkedQueue<Integer>();
            for(int i=0;i<a.length;i++) {
                queue1.enQueue(a[i]);
                queue2.enQueue(a[i]);
                System.out.print(a[i]+" ");
            }

            System.out.println("入队");
            //迭代
            for (Integer s : queue1) {
                System.out.print(s+" ");
            }
            System.out.println("出队");
            for (Integer s : queue2) {
                System.out.print(s+" ");
            }
        }
    }

运行结果：

应用

Josephus问题：

问题描述：N个身陷绝境的人一致同意通过以下方式减少生存人数。他们围成一圈（位置记为0到N-1）并从第一个人开始报数，报到M的人被杀死，直到最后一人留下来。找到不会被杀死的位置。

思路： 需要一个辅助队列，将0到N-1全部依次入队，然后依次出队，再将未被杀死的人（未报到M）入队，构成循环。打印出人们被杀死的顺序，最后一个即为不会被杀死的位置。

import java.util.Scanner;
import queue.LinkedQueue;
/**
 * Josephus问题
 * @author Gain
 *
 */
public class Josephus {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        LinkedQueue<Integer> q = new LinkedQueue<Integer>();
        System.out.println("输入人数N：");
        int N = sc.nextInt();
        System.out.println("输入报数M：");
        int M = sc.nextInt();
        sc.close();

        for(int i=0;i<N;i++) {
            q.enQueue(i);
        }
        while(!q.isEmpty()) {
            for(int i=1;i<M;i++) {
                q.enQueue(q.deQueue());//【核心代码】
            }
            System.out.print(q.deQueue() + " ");
        }
    }
}

运行结果：