队列

抽象数据类型描述：

 

public interface Queue {

    

    // 先进先出只能从队首删除、队尾插入

    public void clear();

    public void enqueue(Object obj);        // 在队尾插入一个新元素

    public Object dequeue();        // 删除并返回队首元素

    

    public boolean isEmpty();

    public int size();

    public Object peek();        // 返回队首元素

    

}

数组实现队列：

 

public class ArrayQueue implements Queue {



    private static final int DEFAULT_SIZE = 10;

    private Object[] array;

    private int front;        // 指向队首元素

    private int rear;        // 指向队尾元素的后继位置

    private int count;



    // 构造方法，构造队列、初始化

    public ArrayQueue() {

        array = new Object[DEFAULT_SIZE];

        front = rear = count = 0;

    }



    public void clear() {

        for (int i = 0; i < array.length; i++) {

            array[i] = null;

            front = rear = count = 0;

        }

    }



    public Object dequeue() {

        if (count == 0) {

            throw new IllegalStateException();

        }

        Object obj = array[front];

        array[front++] = null;        // 队首指针递增

        if (front == array.length) {

            front = 0;

        }

        count--;

        return obj;

    }

    

    /* 

     * 因为front=0时队列不一定为空，rear = array.length时队列不一定放满了。例如当rear = 

     * array.length时，front=3，(array[0]、、array[1]、array[2]这3个元素已经删除

     * front才会移动到3)     * 

     * 

     * */

    public void enqueue(Object obj) {

        if (count == array.length) {

            expand();

        }

        array[rear++] = obj;        // 队尾指针递增

        if (rear == array.length) {

            rear = 0;

        }

        count++;

    }



    /*

     * 不论经过多少次的增加、删除，front与rear的具体位置在 哪里，最后当循环数组(队列)

     * 放满的时候：front = rear ，front + i其实就是将循环队列“拉直”，然后我们再给

     * front赋值0，rear赋值array.length。当我们把数组元素复制到新数组之后队首位置就

     * 在 新数组的左端啦。

     *  

     */

    private void expand() {

        Object[] newArray = new Object[2 * array.length];

        for (int i = 0; i < count; i++) {

            newArray[i] = array[(front + i) % array.length];

        }

        front = 0;

        rear = array.length;

        array = newArray;

    }



    public boolean isEmpty() {

        return count == 0;

    }



    public Object peek() {

        if (count ==0) {

            throw new IllegalStateException();

        }

        return array[front];

    }



    public int size() {

        return count;

    }

    

    // 总是从头开始

    public String toString() {

        String buf = new String("[ ");

        for (int i = 0; i < count; i++) {

            if (i > 0) {

                buf += ", ";

            }

            buf += array[(front + i) % array.length].toString();

        }

        buf += " ]";

        return buf;

    }



}

 

单向链表实现队列：

public class LinkedQueue implements Queue {

    

    // 链表节点类

    private static class SLLNode {

        private Object data;

        private SLLNode next;



        public SLLNode() {



        }



        public SLLNode(Object data) {

            this.data = data;

        }



        public SLLNode(Object data, SLLNode next) {

            this.data = data;

            this.next = next;

        }



        public Object getData() {

            return data;

        }



        public void setData(Object data) {

            this.data = data;

        }



        public SLLNode getNext() {

            return next;

        }



        public void setNext(SLLNode next) {

            this.next = next;

        }



        public String toString() {

            return data.toString();

        }

    }

    

    private SLLNode front;        // 指向单向链表第一个节点的引用

    private SLLNode rear;        // 指向单向链表最后一个节点的引用

    private int count;

    

    public LinkedQueue () {

        clear();

    }

    

    public void clear() {

        front = rear = null;

        count = 0;

    }



    public Object dequeue() {

        if (count == 0) {

            throw new IllegalStateException();

        }

        Object obj = front.data;

        front = front.next;

        // 当前front没有了后继元素(即队列只剩下一个元素)，删除后链表为空，队列为空

        if (front == null) {

            rear = null;

        }

        count --;

        return obj;

    }



    public void enqueue(Object obj) {

        SLLNode temp = new SLLNode(obj, null);

        if (this.isEmpty()) {        //队列为空

            front = temp;

        } else {

            rear.next = temp;

        }

        rear = temp;

        count ++;

    }



    public boolean isEmpty() {

        return count == 0;

        // return rear == null;

    }



    public Object peek() {

        if (this.isEmpty()) {

            throw new IllegalStateException();

        }

        return front.data;

    }



    public int size() {

        return count;

    }

    

    public String toString() {

        String buf = new String("[ ");

        for (SLLNode curr = front; curr != null; curr = curr.next) {

            if (curr != front) {

                buf += ", ";

            }

            buf += curr.data.toString();

        }

        buf += " ]";

        return buf;

    }



}

测试类：

public class QueueTest {



    /**

     * @param args

     */

    public static void main(String[] args) {

        Queue qa = new ArrayQueue();

        int[] array = new int[]{1,2,3,4,5,6,7,8,9};

        qa.enqueue("a");

        qa.enqueue(1);

        qa.enqueue(array);

        qa.enqueue(array[3]);

        qa.enqueue(array.length);

        qa.enqueue("6");

        System.out.println(qa.toString());

        qa.dequeue();

//        qa.dequeue();

        System.out.println(qa.toString());

        System.out.println(qa.size());

        

        Queue ql = new LinkedQueue();

        ql.enqueue(array);

        ql.enqueue(array.length);

        ql.enqueue(array.hashCode());

        System.out.println(ql.toString());

    }



}

结果：

[ a, 1, [I@1fb8ee3, 4, 9, 6 ]

[ 1, [I@1fb8ee3, 4, 9, 6 ]

5

[ [I@1fb8ee3, 9, 33263331 ]