數據結構之鏈表，使用鏈表實現棧以及使用鏈表實現隊列

1、結合之前實現的鏈表這個數據結構，如果只對鏈表的頭部進行增加和刪除，時間復雜度是O(1)的，只對鏈表的頭部進行查詢的話，時間復雜度是O(1)的。那么，滿足這樣的數據結構是什么呢，就是棧，棧這種數據結構是后入先出的，或者先進后出的，只對棧的一端，就是棧頂進行操作，無論是添加元素、刪除元素、查詢元素，都是在棧頂進行的。所以對於鏈表來說，可以將鏈表的頭部當作棧頂，用鏈表做為棧的底層實現來實現一個棧。

創建一個棧的接口，可以使用數組的方式或者鏈表的方式進行實現棧的功能哦！

package com.stack;

/**
 * @param <E> 使用泛型，可以接受任何數據類型的
 */
public interface Stack<E> {

    /**
     * 獲取到棧里面的大小
     *
     * @return
     */
    public int getSize();

    /**
     * 判斷棧是否為空
     *
     * @return
     */
    public boolean isEmpty();

    /**
     * 向棧中添加一個元素，即入棧
     *
     * @param e
     */
    public void push(E e);

    /**
     * 從棧中取出棧頂的元素，即出棧
     *
     * @return
     */
    public E pop();

    /**
     * 查看棧頂的元素
     *
     * @return
     */
    public E peek();

}

由於之前已經使用過數組實現棧，所以這里使用的是鏈表實現棧的功能，具體代碼，如下所示：

package com.linkedlist;

import com.stack.Stack;

/**
 *
 */
public class LinkedListStack<E> implements Stack<E> {

    // 自己實現的LinkedList鏈表這種數據結構，私有的鏈表類對象。
    private LinkedList<E> linkedList;

    /**
     * 構造函數，創建一個LinkedList對象
     */
    public LinkedListStack() {
        linkedList = new LinkedList<>();
    }

    /**
     * 返回鏈表實現的棧的大小
     *
     * @return
     */
    @Override
    public int getSize() {
        return linkedList.getSize();
    }

    /**
     * 返回鏈表實現的棧是否為空
     *
     * @return
     */
    @Override
    public boolean isEmpty() {
        return linkedList.isEmpty();
    }

    /**
     * 向鏈表實現的棧中添加元素，即入棧操作，將元素添加到棧的棧頂
     *
     * @param e
     */
    @Override
    public void push(E e) {
        // 對鏈表的頭部進行操作，時間復雜度是O(1)
        linkedList.addFirst(e);
    }

    /**
     * 從鏈表實現的棧中刪除元素，即出棧操作
     *
     * @return
     */
    @Override
    public E pop() {
        // 對鏈表的頭部取出元素操作，時間復雜度是O(1)
        return linkedList.removeFirst();
    }

    /**
     * 查看棧頂的元素
     *
     * @return
     */
    @Override
    public E peek() {
        // 對鏈表的頭部查看元素操作，時間復雜度是O(1)
        return linkedList.getFirst();
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        // 鏈表的左側是棧頂哦！
        stringBuilder.append("Stack：top ");
        stringBuilder.append(linkedList);
        return stringBuilder.toString();
    }

    public static void main(String[] args) {
        LinkedListStack<Integer> linkedListStack = new LinkedListStack<>();
        for (int i = 0; i < 10; i++) {
            // 入棧操作
            linkedListStack.push(i);
            System.out.println(linkedListStack.toString());
        }

        // 出棧操作
        linkedListStack.pop();
        System.out.println("出棧操作: " + linkedListStack.toString());

        // 獲取到棧的大小
        int size = linkedListStack.getSize();
        System.out.println("獲取到棧的大小: " + size);

        // 獲取到棧頂的元素內容
        Integer peek = linkedListStack.peek();
        System.out.println("獲取到棧頂的元素內容: " + peek);
    }

}

2、數組棧和鏈表棧的復雜度都是一致的，都是O(1)的。即使運行時間略有區別。對數組棧的性能和鏈表棧的性能進行對比分析。

package com.main;

import com.linkedlist.LinkedListStack;
import com.queue.ArrayQueue;
import com.queue.LoopQueue;
import com.queue.Queue;
import com.stack.ArrayStack;
import com.stack.Stack;

import java.util.Random;

/**
 *
 */
public class Main {

    /**
     * 測試使用stack運行opCount個push和pop操作所需要的時間，單位：秒
     * <p>
     * 數組棧和鏈表棧的復雜度都是一致的，都是O(1)的。即使運行時間略有區別。
     *
     * @param queue
     * @param opCount
     * @return
     */
    public static double queuePerforms(Stack<Integer> queue, int opCount) {
        // 開始時間
        long startTime = System.nanoTime();

        Random random = new Random();
        // 入隊操作
        for (int i = 0; i < opCount; i++) {
            queue.push(random.nextInt(Integer.MAX_VALUE));
        }

        // 出隊操作
        for (int i = 0; i < opCount; i++) {
            queue.pop();
        }

        // 結束時間
        long endTime = System.nanoTime();

        // 秒與納秒之前差九位數
        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int opCount = 100000;// 十萬次

        // 數組棧的性能
        // 對於數組棧來說，需要重新分配靜態數組，將原來的數組拷貝到新的數組中，即擴容操作。
        ArrayStack<Integer> arrayStack = new ArrayStack<>();
        double time1 = queuePerforms(arrayStack, opCount);
        System.out.println("ArrayStack, time:  " + time1 + " s");


        // 鏈表棧的性能
        // 其實這個時間比較復雜，因為LinkedListStack中包含更多的new操作。
        LinkedListStack<Integer> linkedListStack = new LinkedListStack<>();
        double time2 = queuePerforms(linkedListStack, opCount);
        System.out.println("LinkedListStack, time: " + time2 + " s");
    }

}

3、帶有尾指針的鏈表，使用鏈表實現隊列。

　　1）、結合之前實現的鏈表這個數據結構，如果只對鏈表的頭部進行增加和刪除，時間復雜度是O(1)的，只對鏈表的頭部進行查詢的話，時間復雜度是O(1)的。如果對鏈表的尾部進行操作的話，無論是添加元素還是刪除元素，時間復雜度都是O(n)的。對於隊列這種數據結構來說，需要在這種線性結構中的一端插入元素，在另外一端刪除元素，所以我們勢必會在這種線性結構的兩端同時操作，那么此時就會有一端的操作，它的復雜度是O(n)級別的。
　　2）、對於使用數組來實現隊列的時候，也遇到類似問題，需要改進數組實現隊列的方式，所以產生了循環隊列，對於鏈表也存在同樣的問題，我們不能直接使用之前的鏈表結構，需要引入改進該鏈表，由此引入了尾指針。改進思路，對於鏈表來說，在鏈表的頭部的位置，不管插入元素還是刪除元素，都十分容易，因為對於鏈表來說，有head這個變量來幫助我們標記鏈表的頭部在哪里，擁有了這個標記以后，在鏈表的頭部進行添加元素還是刪除元素都是容易的。
　　3）、所以在鏈表的尾部，再創建一個Node類型的變量tail，來標記鏈表的尾部在哪里，所以，如果知道了鏈表的尾部，再添加一個元素會是非常容易的。這就相當於給鏈表添加元素，在鏈表索引為size的位置添加一個元素，換句話說，tail這個位置的節點就是我們待添加元素的位置，也就是最后一個位置之前的那個節點，相應的，我們在tail這個節點的后面添加一個節點是非常容易的。
　　4）、所以，對於鏈表來說，在head端和tail端添加節點都是非常容易的。

3.1、考慮，如何在tail端刪除一個節點。鏈表新增尾指針，使用鏈表實現隊列。

　　1）、如何在tail端刪除一個節點，注意的是，鏈表的結構不是對稱的，之前的鏈表結構中，想要刪除一個元素，需要找到待刪除元素的前一個位置的節點，如果現在想要刪除tail這個位置所指向的節點，就要找到tail這個位置它前一個位置的節點，如何找到tail這個節點之前的那個位置節點呢，對於此時的鏈表來說，只有一個next指向后一個節點，所以此時是無法使用O(1)的復雜度直接找到tail這個節點它之前那個位置的節點的，此時，還是需要從head頭部節點循環遍歷，這樣時間復雜度變成了O(n)，所以，即使在鏈表的尾部標記了tail，我們還是無法使用O(1)的復雜度直接刪除tail這個位置的節點的。即從tail刪除元素不容易的。
　　2）、但是，對於，在鏈表的頭部head這個節點刪除或者新增一個節點非常容易的，所以根據此分析，改進鏈表，即在鏈表的尾部添加一個Node節點tail，來標記整個鏈表中尾節點處在什么位置，然后在在鏈表的頭部head這個節點刪除或者新增一個節點非常容易的，對於tail端，我們只是添加元素容易，刪除元素不容易。
　　3）、對於隊列中，隊首和隊尾的選擇，由於tail端刪除元素不容易，只能從tail端插入元素，從head端刪除元素，所以，刪除元素的這一端在隊列中稱為隊首，負責出隊，添加元素的這一端稱為隊尾，負責入隊。
　　4）、注意，由於對這個鏈表的操作全都在鏈表的一側完成，也就是head端或者tail端完成，就不使用虛擬頭節點了，因為不牽扯到對鏈表的中間的一個元素進行插入或者刪除這樣的操作，所以也就沒有必要統一對鏈表的中間元素進行操作和對鏈表兩側的元素進行操作，他們之間可能帶來的邏輯不統一的問題。
如果添加了tail這個Node節點以后，還需要注意一個情況，就是此時，當我們的鏈表為空的時候。head和tail都將指向空，由於沒有虛擬頭節點，要注意鏈表為空的情況。

鏈表新增tail節點，結合head頭部節點的鏈表實現隊列的功能。

package com.queue;

/**
 * 使用鏈表創建隊列
 *
 * @param <E>
 */
public class LinkedListQueue<E> implements Queue<E> {

    // 由於LinkedListQueue也是一個鏈表，所以需要鏈表的節點Node
    // 鏈表是由一個一個節點組成
    private class Node {
        // 設置公有的，可以讓外部類進行修改和設置值
        public E e;// 成員變量e存放元素
        public Node next;// 成員變量next指向下一個節點，指向Node的一個引用

        /**
         * 含參構造函數
         *
         * @param e
         * @param next
         */
        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }

        /**
         * 無參構造函數
         */
        public Node() {
            this(null, null);
        }

        /**
         * 如果用戶只傳了e，那么可以調用含參構造函數，將next指定為null
         *
         * @param e
         */
        public Node(E e) {
            this(e, null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }


    // 創建頭節點和尾節點
    private Node head;// 鏈表的頭節點
    private Node tail;// 鏈表的尾節點
    private int size;// 鏈表的長度大小

    /**
     * 無參構造函數，和默認的構造函數做的是一樣的。
     * 鏈表初始化的時候head、tail都是空
     */
    public LinkedListQueue() {
        head = null;
        tail = null;
        size = 0;
    }

    /**
     * 使用鏈表實現的隊列的，入隊操作。
     * <p>
     * 鏈表實現的入隊操作，是從鏈表的尾部進行。
     * <p>
     * 此方法是O(1)級別的復雜度。
     *
     * @param e
     */
    @Override
    public void enqueue(E e) {
        // 首先判斷鏈表的尾部是否為空，如果tail為空，說明head也是空的，此時鏈表是空的
        // 但凡鏈表包含元素，tail指向的是尾節點位置，就不會是空的。
        if (tail == null) {
            // 如果尾部節點是空，就直接在尾部插入一個系節點，此節點存儲e元素
            tail = new Node(e);
            // 此時，莫要忘記維護head，此時head==tail
            head = tail;
        } else {
            // 如果tail指向的位置不為空，那么在tail的next位置，創建新節點，存儲元素e
            tail.next = new Node(e);
            // 然后維護tail的位置即可，讓tail指向鏈表的最后一個位置的元素。
            // 新的tail等於剛剛創建的tail的next。此時就不用維護head頭部節點的位置了。
            tail = tail.next;
        }

        // 最后，維護size的大小即可
        size++;
    }

    /**
     * 使用鏈表實現的隊列的，出隊操作。
     * <p>
     * 此方法是O(1)級別的復雜度。不需要遍歷隊列所以元素
     *
     * @return
     */
    @Override
    public E dequeue() {
        // 出隊過程，首先，需要判斷隊列能否可以出隊一個元素。
        // 換句話說，如果此時隊列為空的時候，就無法出隊，拋出異常即可。
        if (isEmpty()) {
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        }

        // 如果有元素，就進行出隊操作。
        // 此操作類似於從鏈表的頭部刪除一個元素。
        // 首先，returnNode出隊元素所在的節點應該就是head這個位置所指向的節點。
        Node returnNode = head;
        // 讓head指向原來head的next下一個位置節點。新的head跳過returnNode，直接指向head.next。
        head = head.next;

        // 這樣一來returnNode的next其實相當於指向了head這個節點。
        // 此時讓returnNode從鏈表中斷開，需要操作的是returnNode.next = null;
        returnNode.next = null;

        // 此時，需要注意，當指向了head = head.next的時候，也就是我們的那個head這個節點指向了原來
        // 我們頭節點的下一個節點，但是這個下一個節點可能是空的，也即是說，我們的鏈表只有一個元素。
        // 我們把returnNode出隊之后，我們的鏈表就為空了。此時需要判斷head是否為空，然后維護tail這個節點。
        if (head == null) {
            // 此時需要判斷head是否為空，然后維護tail這個節點。讓tail節點為空。
            // 例如，只有一個元素，head和tail都指向這個元素，如果經過上面的出隊操作之后，
            // 如果此時tail還指向此元素，就錯了，所以需要維護tail的節點為空即可。
            tail = null;
        }

        // 維護size的大小
        size--;

        // 返回出隊的節點元素
        return returnNode.e;
    }

    /**
     * 使用鏈表實現的隊列的，獲取到隊首元素。
     *
     * @return
     */
    @Override
    public E getFront() {
        // 獲取隊首元素
        if (isEmpty()) {
            throw new IllegalArgumentException("Queue is empty.");
        }

        // 否則返回隊首的元素即可
        return head.e;
    }

    /**
     * 返回鏈表的大小
     *
     * @return
     */
    @Override
    public int getSize() {
        return size;
    }

    /**
     * 判斷鏈表是否為空
     *
     * @return
     */
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        // 隊首，負責出隊
        stringBuilder.append("Queue ： front ");
        // 使用while循環進行循環
        Node current = head;
        while (current != null) {
            stringBuilder.append(current + "->");
            current = current.next;
        }
        // 隊尾，負責入隊
        stringBuilder.append("NULL tail ");
        return stringBuilder.toString();
    }

    public static void main(String[] args) {
        // 基於鏈表實現的隊列
        LinkedListQueue<Integer> linkedListQueue = new LinkedListQueue<>();
        // 隊列的入隊操作
        for (int i = 0; i < 10; i++) {
            linkedListQueue.enqueue(i);
            // System.out.println("隊列的入隊操作: " + linkedListQueue);
            System.out.println(linkedListQueue);

//            if (i % 3 == 2) {
//                linkedListQueue.dequeue();
//                System.out.println(linkedListQueue);
//            }
        }

        // 隊列的出隊操作
        linkedListQueue.dequeue();
        System.out.println("隊列的出隊操作: " + linkedListQueue.toString());

        // 獲取到隊首的元素
        Integer front = linkedListQueue.getFront();
        System.out.println("獲取到隊首的元素: " + front);
    }

}

4、數組隊列，循環數組隊列，鏈表隊列的性能測試比較。如下所示：

package com.queue;

import java.util.Random;

/**
 *
 */
public class Main {

    /**
     * 測試使用queue運行opCount個enqueue和dequeue操作所需要的時間，單位：秒
     *
     * @param queue
     * @param opCount
     * @return
     */
    public static double queuePerforms(Queue<Integer> queue, int opCount) {
        // 開始時間
        long startTime = System.nanoTime();

        Random random = new Random();
        // 入隊操作
        for (int i = 0; i < opCount; i++) {
            queue.enqueue(random.nextInt(Integer.MAX_VALUE));
        }

        // 出隊操作
        for (int i = 0; i < opCount; i++) {
            queue.dequeue();
        }

        // 結束時間
        long endTime = System.nanoTime();

        // 秒與納秒之前差九位數
        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int opCount = 100000;// 十萬次

        // 數組隊列的性能
        // 影響數組隊列性能的是出隊操作，因為每一個元素都要進行前移操作
        // 時間復雜度是O(n*n)。
        ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
        double time1 = queuePerforms(arrayQueue, opCount);
        System.out.println("ArrayQueue, time:  " + time1 + " s");


        // 循環隊列的性能
        // 時間復雜度是O(1)。
        LoopQueue<Integer> loopQueue = new LoopQueue<>();
        double time2 = queuePerforms(loopQueue, opCount);
        System.out.println("LoopQueue, time: " + time2 + " s");


        // 鏈表隊列的性能。循環隊列和鏈表隊列的時間復雜度是一樣的。
        // 時間復雜度是O(1)。
        LinkedListQueue<Integer> linkedListQueue = new LinkedListQueue<>();
        double time3 = queuePerforms(linkedListQueue, opCount);
        System.out.println("LinkedListQueue, time: " + time3 + " s");
    }

}

 

作者：別先生

博客園：https://www.cnblogs.com/biehongli/

如果您想及時得到個人撰寫文章以及著作的消息推送，可以掃描上方二維碼，關注個人公眾號哦。