数据结构与算法（六）队列 - 数组队列+链表队列

public class Queue {

    @Test
    public void test() {
        //均摊时间复杂度O(1)
//        ArrayQuene arrayQuene = new ArrayQuene();
//        arrayQuene.enqueue(1);
//        arrayQuene.enqueue(2);
//        arrayQuene.enqueue(3);
//        arrayQuene.show();
//        System.out.println("===================" + arrayQuene.outqueen());
//        System.out.println("===================" + arrayQuene.outqueen());
//        arrayQuene.enqueue(4);
//        arrayQuene.enqueue(5);
//        arrayQuene.enqueue(6);
//        arrayQuene.show();
//        System.out.println("===================" + arrayQuene.outqueen());
//        arrayQuene.show();
//        arrayQuene.enqueue(11);
//        arrayQuene.enqueue(22);
//        System.out.println("===================" + arrayQuene.outqueen());
//        arrayQuene.show();
//        System.out.println("===================" + arrayQuene.outqueen());
//        System.out.println("===================" + arrayQuene.outqueen());
//        System.out.println("===================" + arrayQuene.outqueen());
//        arrayQuene.show();

        //还是链表实现更爽一点，毕竟不用像数组那样，考虑移位、扩容
        LinkedQueue linkedQueue = new LinkedQueue();
        linkedQueue.enqueue(1);
        linkedQueue.enqueue(2);
        linkedQueue.enqueue(3);
        linkedQueue.show();
        System.out.println("===================pop " + linkedQueue.outqueue());
        System.out.println("===================pop " + linkedQueue.outqueue());
        linkedQueue.enqueue(44);
        linkedQueue.enqueue(55);
        linkedQueue.show();

    }

    class ArrayQuene {
        int[] array = new int[4];
        double factor = 0.75;
        int head = 0;
        int tail = 0;

        public void enqueue(int value) {
            //尾部超过整体数组一定长度后扩容
            if (tail > array.length * factor) {
                //长度翻倍
                int[] arrayTemp = new int[array.length * 2];
                //head到tail移动过去
                for (int i = 0; i < tail - head; i++) {
                    arrayTemp[i] = array[head + i];
                }
                tail = tail - head;
                head = 0;
                //赋值
                array = arrayTemp;
            }
            if (tail < array.length) {
                array[tail] = value;
                tail++;
            }

        }

        public int outqueen() {
            int value = 0;
            if (head < tail) {
                value = array[head];
                head++;

                //如果超过一半的空间未利用，则发起位置移动
                if (head > array.length / 2) {
                    //整体向前移动head-1位，这里-1是因为上面刚刚执行过head++
                    for (int i = head - 1; i < tail; i++) {
                        array[i - (head - 1)] = array[i];
                    }
                    tail = tail - (head - 1);
                    head = 0;
                }
            }
            return value;
        }

        public void show() {
            for (int i = head; i < array.length; i++) {
                System.out.println("==============[" + array[i] + "] in " + array.length);
            }
        }
    }

    class LinkedQueue {
        Node head = null;

        public void enqueue(int val) {
            Node temp = new Node(val);
            if (head == null) {
                head = temp;
                return;
            }
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = temp;
        }

        public int outqueue() {
            if (head == null) {
                return 0;
            }

            int val = head.val;
            head = head.next;
            return val;
        }

        public void show() {
            Node current = head;
            while (current != null) {
                System.out.println("==================" + current.val);
                current = current.next;
            }
        }
    }
}