队列--数组实现

　　可以仿照利用数组实现栈的过程，使用数组实现队列。以front指向队首元素，值始终为数组首元素a[0]。出队时，front保持不变，删除队首元素，其余元素依次向前移动，时间复杂度是O(n)。入队时，根据队列大小将元素存储到相应位置。上述实现因为不断移动元素，效率太低。因此以下使用环形数组的形式来构造队列。定义两个变量：

front:指向队首元素。

rear:指向队尾元素的下一个位置。
另外设环形数组大小为len。初始状态下，front=rear=0。入队时，在rear指向的位置存储元素，然后令rear=(rear+1)%len。出队时，删除front指向的元素，然后令front=(front+1)%len。最后，front=rear既是队满的判断条件又是队空的判断条件，不过可以完美解决。在入队方法enqueue中，size==CAPACITY，那么就是队满了。在出队方法中，如果size==0，那么即使队空了。不过这种方法会导致原有队首元素被覆盖(覆盖原队首元素不符合队列的设计初衷)，可以通过禁止队列规模超过CAPACITY-1的方法来解决此问题。这样，只有队空的时候才有front=rear。使用这种方法利用环形队列实现了”烫手山芋“游戏。烫手山芋游戏规则：一群小孩围成一圈，在他们之间传递山芋。其中，一个小孩负责数数，每数一次，就把山芋转交给左边的邻居，从1开始数起，数到k时拿着山芋的孩子出列，然后重新从1开始说，从”淘汰“孩子的邻居开始重新传递山芋。实现代码如下：

　　首先给出Queue接口的代码：

/**
 * Created by hfz on 2016/8/2.
 */
public interface Queue {
    void enqueue(Object obj);//入队
    Object dequeue();//出队并返回对首元素
    int getSize();//队列元素个数
    boolean isEmpty();//判断队列是否为空
    Object front();//返回对首元素
}

　　然后是实现代码：

import java.util.Objects;
import java.util.Random;

/**
 * Created by hfz on 2016/8/2.
 */
/*
可以仿照利用数组实现栈的过程，使用数组实现队列。以front指向队首元素，值始终为数组首元素a[0]。
出队时，front保持不变，删除队首元素，其余元素依次向前移动，时间复杂度是O(n)。
入队时，根据队列大小将元素存储到相应位置。

上述实现因为不断移动元素，效率太低。因此以下使用环形数组的形式来构造队列。
定义两个变量：
front:指向队首元素。
rear:指向队尾元素的下一个位置。
另外设环形数组大小为len
初始状态下，front=rear=0。入队时，在rear指向的位置存储元素，然后令rear=(rear+1)%len。
出队时，删除front指向的元素，然后令front=(front+1)%len。
最后，front=rear既是队满的判断条件又是队空的判断条件，不过可以完美解决。在入队方法enqueue中，
size==CAPACITY，那么就是队满了。在出队方法中，如果size==0，那么即使队空了。不过这种方法会导致原有队首元素被覆盖(覆盖原队首元素
不符合队列的设计初衷)，可以通过禁止队列规模超过CAPACITY-1的方法来解决此问题。这样，只有队空的时候才有front=rear。
各种方法时间复杂度均是O(1)
 */

public class Queue_Array implements Queue {
    private static int CAPACITY=40;
    private int capacity=0;
    private Object[] S;
    private int front=0;
    private int rear=0;

    public Queue_Array(int capacity){
        this.capacity=capacity;
        S=new Object[capacity];
    }
    public Queue_Array(){
        this(CAPACITY);
    }
    public void enqueue(Object obj){
        if(getSize()==CAPACITY-1){//队满
            throw new ExceptionQueueFull("队满，不能入队");
        }
        else{//队未满,入队
            try {

                S[rear] = obj;
                //front=(front+1)%CAPACITY;//队首指针加1，再对数组长度取模。
                rear = (rear + 1) % CAPACITY;//队尾指针加1，再对数组长度取模。
            }
            catch (ArrayIndexOutOfBoundsException ex){
                System.out.println();
            }
        }

    }
    public Object dequeue(){
        if(rear==front){
            throw new ExceptionQueueEmpty("队空，不能出队");
        }
        else{
            Object obj=S[front];
            S[front]=null;
            front=(front+1)%CAPACITY;
            return obj;
        }
    }

    public Object front(){
        if(rear==front){
            throw new ExceptionQueueEmpty("队空，没有队首元素");
        }
        else{
             return S[front];
        }
    }
    public boolean isEmpty(){
        if(front==rear){
            return true;
        }
        else {
            return false;
        }
    }
    public int getSize(){
        return (CAPACITY+rear-front)%CAPACITY;//rear取模之后可能小于front，不能直接用(rear-front)
    }


    public static void main(String[] args){
        String[] children={"A","B","C","D","E","F","G","H","I","J","K"};
        Queue_Array queue=new Queue_Array();
//        int len=queue.capacity;
       for(String s:children){
           queue.enqueue(s);
       }
        Random rand=new Random();
        Object dequeueObj;
        int k=rand.nextInt(children.length-1)+1;
        //k=4;
        while(queue.getSize()!=1){
            for(int i=1;i<k;++i){
                dequeueObj=queue.dequeue();
                queue.enqueue(dequeueObj);
            }
            dequeueObj=queue.dequeue();
            System.out.println(String.format("%s 退出",(String)dequeueObj));
        }
        System.out.println(String.format("when k is %s winner is %s ",k,queue.front()));
    }
}

class ExceptionQueueEmpty extends RuntimeException {
    public ExceptionQueueEmpty(String err){
        super(err);
    }
}
class ExceptionQueueFull extends RuntimeException{
    public ExceptionQueueFull(String err){
        super(err);
    }
}

　　其实，就烫手山芋游戏来说，使用如下的入队和出队方法更好：

　　在入队方法enqueue中，size==CAPACITY，那么就是队满了。在出队方法中，如果size==0，那么即是队空了。这种方法会导致原有队首元素被覆盖，正好符合题意，可以将队列大小设置为孩子个数。如果使用禁止队列规模超过CAPACITY-1的方法，队列大小的设置要大于孩子个数，否则入队时会提示“队列已满”。