數據結構與算法（六）隊列 - 數組隊列+鏈表隊列

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;
            }
        }
    }
}