Java数据结构和算法——队列

介绍

队列（Queue），是一种线性存储结构。它有以下几个特点：

1. 数据按照”先进先出”方式进出队列；
2. 只允许在”队首”进行删除操作，”队尾”进行插入操作。

队列通常包括的两种操作：入队列 和 出队列。

示意图

队列中有10，20，30共3个数据。

出队列

出队列前：队首是10，队尾是30。
出队列后：出队列(队首)之后。队首是20，队尾是30。

入队列

入队列前：队首是20，队尾是30。
入队列后：40入队列(队尾)之后。队首是20，队尾是40。

队列的Java实现

Java实现一：数组实现的队列，能存储任意类型的数据

实现代码(ArrayQueue.java)

public class ArrayQueue {

    private int[] array;
    private int count;

    public ArrayQueue(int length) {
        array = new int[length];
    }

    public void add(int num) {
        array[count++] = num;
    }

    public int header() {
        return array[0];
    }

    public int pop() {
        int value = array[0];
        count--;
        for (int i = 1; i < array.length; i++) {
            array[i-1] = array[i];
        }

        return value;
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    public int size() {
        return count;
    }

public static void main(String[] args) {

        int temp = 0;

        ArrayQueue queue = new ArrayQueue(12);

        // 将10, 20, 30 依次推入栈中
        queue.add(10);
        queue.add(20);
        queue.add(30);

        // 将“栈顶元素”赋值给temp，并删除“栈顶元素”
        temp = queue.pop();
        System.out.printf("temp=%d\n", temp);

        // 只将“栈顶”赋值给temp，不删除该元素.
        temp = queue.header();
        System.out.printf("temp=%d\n", temp);

        queue.add(40);

        System.out.printf("isEmpty()=%b\n", queue.isEmpty());
        System.out.printf("size()=%d\n", queue.size());
        while (!queue.isEmpty()) {
            System.out.printf("size()=%d\n", queue.pop());
        }

    }
}

运行输出结果：

temp=10
temp=20
isEmpty()=false
size()=3
size()=20
size()=30
size()=40

Java实现二：Java的 Collection集合 中自带的”队列”(LinkedList)的示例

实现代码(StackList.java)

public class StackList<T> {

    // 向队列添加数据时：(01) 将“已有的全部数据”都移到mInStack中。 (02) 将“新添加的数据”添加到mInStack中。
    private Stack<T> mInStack;
    // 从队列获取元素时：(01) 将“已有的全部数据”都移到mOutStack中。(02) 返回并删除mOutStack栈顶元素。
    private Stack<T> mOutStack;

    private int mCount = 0;

    public StackList() {
        mInStack = new Stack<>();
        mOutStack = new Stack<>();
        mCount = 0;
    }

    private void add(T t) {
        while (!mOutStack.isEmpty()) {
            mInStack.push(mOutStack.pop());
        }
        // 将“新添加的数据”添加到mInStack中
        mInStack.push(t);
        mCount++;
    }

    private T get() {
        while (!mInStack.isEmpty()) {
            mOutStack.push(mInStack.pop());
        }
        mCount--;
        return mOutStack.pop();
    }

    private int size() {
        return mCount;
    }

    private boolean isEmpty() {
        return mCount == 0;
    }

    public static void main(String[] args) {
        StackList<Integer> slist = new StackList<Integer>();

        // 将10, 20, 30 依次推入栈中
        slist.add(10);
        slist.add(20);
        slist.add(30);

        System.out.printf("isEmpty()=%b\n", slist.isEmpty());
        System.out.printf("size()=%d\n", slist.size());
        while (!slist.isEmpty()) {
            System.out.printf("%d\n", slist.get());
        }
    }

}

运行输出结果：

isEmpty()=false
size()=3
10
20
30

参考学习：http://www.cnblogs.com/skywang12345/p/3562279.html