2. 程式人生 > >《資料結構與演算法之美》專欄閱讀筆記2——線性表

《資料結構與演算法之美》專欄閱讀筆記2——線性表

阿新 • • 發佈：2018-11-15

換個方式來寫筆記，最近啃完了《Thinking in Java》，想要在看專欄的時候多做點擴充套件性的東西，比如把難撩的泛型加進來做實現，程式碼還是要寫起來才曉得怎麼寫更酷。總之最近看書的過程中、搜尋答案的過程中發出了很多“哇~超厲害！超酷！我也要這樣棒棒噠！”的嘆聲。新的開始，繼續加油

文章目錄

陣列和連結串列

簡單說明下：
1、單鏈表反轉：兩種方式，新建連結串列，逆序遍歷轉儲；遞迴改變next的指向。此處用的是遞迴。
2、環的檢測：快慢指標法。對於環的入口節點的證明還是每太吃透（數學不好？
3、有序連結串列合併：直接是寫了個有序連結串列，insert。在插入位置的查詢上應該是可以根據有序這個特點來優化的，偷懶了，沒寫……
4、刪除倒數第N個節點：用雙指標來確定長度。
5、連結串列的中間節點：還是雙指標，寫法和環的檢測很像，木有證明哦，只是畫了簡單的圖來推一下邏輯。（我好像直接刪掉了中間節點，嘎~

程式碼如下
【單鏈表】

public class SingleLinkedList<T> {
    private int size;
    private Node head = new Node();

    public Node addFirst(T data) {
        Node node = new Node(data);
        node.next = head.next;
        head.next = node;
        size++;
        return node;
    }

    public Node addLast(T data) {
        Node tail = getTail();
        Node node = new Node(data);
        node.next = tail.next;
        tail.next = node;
        return node;
    }

    public Node getTail() {
        Node tail = head;
        Node entry = getEntryNodeOfLoop();
        if (entry != null) {
            return entry;
        }

        while (tail != null && tail.next != null) {
            tail = tail.next;
        }
        return tail;
    }

    public Node find(T data) {
        Node ptr = head.next;
        while (ptr != null) {
            if (ptr.item.equals(data)) {
                return ptr;
            }
            ptr = ptr.next;
        }
        return null;
    }

    // 遞迴反轉
    public void reversal() {
        head.next = reversal(head.next);
    }

    // 連結串列反轉
    public Node reversal(Node nextNode) {
        if (nextNode == null || nextNode.next == null) {
            return nextNode;
        }
        Node newHead = reversal(nextNode.next);
        nextNode.next.next = nextNode;
        nextNode.next = null;
        return newHead;
    }

    // 環的檢測，入口節點非空表示有環
    public Node getEntryNodeOfLoop() {
        if (head == null || head.next == null || head.next.next == null) {
            return null;
        }
        Node fastNode = head.next;
        Node slowNode = head.next;
        while (fastNode != null && fastNode.next != null) {
            slowNode = slowNode.next;
            fastNode = fastNode.next.next;
            if (fastNode == slowNode) {
                slowNode = head.next;
                while (slowNode != fastNode) {
                    slowNode = slowNode.next;
                    fastNode = fastNode.next;
                }
                return slowNode;
            }
        }
        return null;
    }

    // 刪除連結串列的倒數第N個節點
    public Node removeFromEnd(int n) {
        Node pHead = head.next;
        Node pTail = pHead;
        for (int i = 0; i < n; i++) {
            pTail = pTail.next;   // 給定的N可以保證該操作有效
        }
        while (pTail.next != null) {
            pHead = pHead.next;
            pTail = pTail.next;
        }

        Node target = pHead.next;
        pHead.next = pHead.next.next;

        return target;
    }
    public Node removeMidNode() {
        Node firstNode = head.next;
        if (firstNode == null || firstNode.next == null) {
            head.next = null;
            return head;
        }
        Node slow = firstNode;
        Node fast = slow.next.next;
        while(fast.next.next != null && slow.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }

        Node target = slow.next;
        slow.next = slow.next.next;
        return target;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        Node node = head;
        while(node != null) {
            sb.append(node.item);
            sb.append(" ");
            node = node.next;
        }
        sb.append("]");
        return sb.toString();
    }

    // 連結串列節點
    private class Node {
        private T item;
        private Node next;

        Node() {
            item = null;
            next = null;
        }
        Node(T data) {
            item = data;
            next = null;
        }
        Node(T data, Node next) {
            this.item = data;
            this.next = next;
        }

        @Override
        public String toString() {
            return "Node: " + item;
        }
    }

    public static void main(String[] args){
        System.out.println(" ---- Test reversal of linkedlist ----");
        SingleLinkedList<String> ssl = new SingleLinkedList<String>();
        for (String s : "A B C D E F G".split(" ")) {
            ssl.addLast(s);
        }

        System.out.println("source: " + ssl);
        ssl.reversal();
        System.out.println("reversal: " + ssl);

        System.out.println(" ---- remove node from end ----");
        ssl.removeFromEnd(3);
        System.out.println("remove the 3rd node from the end: " + ssl);

        System.out.println(" --- remove mid node -----");
        ssl.removeMidNode();
        System.out.println("remove mid node: " + ssl);

        System.out.println(" ---- Check loop in linkedlist ----");
        SingleLinkedList<String> loopList = new SingleLinkedList<String>();
        for (String s : "A B C D E F G H I J K".split(" ")) {
            loopList.addLast(s);
        }

        System.out.println("Set Loop in D");
        loopList.getTail().next = loopList.find("D");

        System.out.println("entry node of loop: " + loopList.getEntryNodeOfLoop());

    }
}

【有序連結串列】

import java.util.Iterator;

/**
 * @Description : TODO
 * @Author : Ellie
 * @Date : 2018/11/7
 */
public class SortedLinkedList<T extends Comparable<T>> {
    Node head = new Node();
    Node curNode = head;


    // 由大到小
    public Node insert(T data) {
        Node cur = head.next;
        Node pre = head;

        while (cur != null && cur.item.compareTo(data) > 0) {
            pre = cur;
            cur = cur.next;
        }
        Node node = new Node(data);
        node.next = cur;
        pre.next = node;

        return node;
    }
    public void insert(Node o) {
        Node cur = head.next;
        Node pre = head;

        while (cur != null && cur.item.compareTo(o.item) > 0) {
            pre = cur;
            cur = cur.next;
        }
        o.next = cur;
        pre.next = o;
    }
    public void insert(SortedLinkedList<T> sortedLinkedList) {
        Node ptr = sortedLinkedList.head.next;
        while (ptr != null) {
            insert(ptr.item);
            ptr = ptr.next;
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        Node node = head.next;
        while (node != null) {
            sb.append(node.item);
            sb.append(" ");
            node = node.next;
        }
        return sb.toString();
    }

    class Node implements Comparable<Node> {
        T item;
        Node next;

        Node() {
            item = null;
            next = null;
        }
        Node(T data) {
            item = data;
            next = null;
        }
        Node(T data, Node next) {
            this.item = data;
            this.next = next;
        }

        public int compareTo(Node o) {
            return item.compareTo(o.item);
        }

        @Override
        public String toString() {
            return "Node: " + item;
        }
    }

    public static void main(String[] args){
        SortedLinkedList<String> sll1 = new SortedLinkedList<String>();
        for (String s : "A B C X Y Z D E F G".split(" ")) {
            sll1.insert(s);
        }
        System.out.println("s1: " + sll1);

        SortedLinkedList<String> sll2 = new SortedLinkedList<String>();
        for (String s : "Q X P J K M D A".split(" ")) {
            sll2.insert(s);
        }
        System.out.println("s2: " + sll2);

        sll1.insert(sll2);
        System.out.println("s1+s2: " + sll1);
    }
}

多寫多練部分完整工程：https://github.com/EllieYY/linkedlistDemo.git

棧

特定的資料結構是對特定場景的抽象。棧這種結構屬於介面比較簡單的，後進先出。

棧的兩種實現：陣列實現的順序棧和連結串列實現的鏈式棧。最近看泛型比較多，實現的時候也用上了。程式碼如下：

// 基於linkedList實現
public class LinkedListStack<T> {
    private LinkedList<T> storage = new LinkedList<T>();
    public boolean push(T item) {
        storage.addFirst(item);
        return true;
    }
    public T pop() {
        return storage.removeFirst();
    }
    public T peek() {
        return storage.getFirst();
    }
}

// 基於陣列實現
public class ObjectArrayStack<T> {
    private Object[] storage = null;
    private int size;
    private int count;

    public ObjectArrayStack(int size) {
        if (size >= 0) {
            this.size = size;
            this.count = 0;
            storage = new Object[size];
        } else {
            throw  new RuntimeException("Illegal stack size: " + size);
        }
    }

    public boolean push(T item) {
        if (count == size) {
            return false;
        }
        storage[count++] = item;
        return true;
    }

    public T pop() {
        if (count == 0) {
            return null;
        }
        --count;
        T item = (T)storage[count];
        storage[count] = null;
        return item;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder(getClass().getSimpleName());
        sb.append(":");
        for (int i = 0; i < count; i++) {
            sb.append(storage[i]).append(" ");
        }
        return sb.toString();
    }

    public static void main(String[] args){
        ObjectArrayStack<String> stack = new ObjectArrayStack<String>(15);
        for (String s : "A B C D E F G H I".split(" ")) {
            stack.push(s);
        }
        System.out.println(stack);
    }
}
擴充套件：泛型與陣列

上面基於陣列的實現是看過其他技術部落格之後這樣寫的。很迷書裡面講的Generator，之前寫的版本是強行把Generator用上了的。
一開始沒有使用Object陣列是因為，看過書中的例子，Object陣列是可以同時放多種型別的資料，最大的弊端就是無法進行編譯器檢查。但是此處因為是泛型類，反而沒有這樣的困擾呢~
強用Generator的程式碼如下：

public class ArrayStack<T> {
    private T[] storage;
    private int size;       // 棧的大小
    private int count;      // 元素的個數

    public ArrayStack(Class<T> type, Generator<T> gen, int n) {
        if (size >= 0) {
            this.size = n;
            this.count = 0;
            storage = Generated.array(type, gen, n);
        } else {
            throw  new RuntimeException("Illegal stack size: " + size);
        }
    }

    public boolean push(T item) {
        if (count == size) {
            return false;
        }
        storage[count++] = item;
        return true;
    }
    public boolean push(Generator<T> gen) {
        if (count == size) {
            return false;
        }
        storage[count++] = gen.next();
        return true;
    }

    public T pop() {
        if (count == 0) {
            return null;
        }
        --count;
        T item = storage[count];
        storage[count] = null;
        return item;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder(getClass().getSimpleName());
        sb.append(":");
        for (int i = 0; i < count; i++) {
            sb.append(storage[i]).append(" ");
        }
        return sb.toString();
    }

    public static void main(String[] args){
        ArrayStack<String> stack = new ArrayStack<String>(String.class,
                new PrimitiveGenerator.String(), 15);
        for (String s : "A B C D E F G H I".split(" ")) {
            stack.push(s);
        }
        System.out.println(stack);
    }
}

關於生成器的示例程式碼可以參考：生成器
在用生成器的過程中也搞明白了一個事情。利用反射機制寫出來的BasicGenerator的使用條件：

  • 具有預設構造器（無參構造器）
  • public

無法用於基本型別和包裝器型別的原因也在於此，所以另外單獨寫了CountingGenerator（書中程式碼的名稱），我改成了PrimitiveGenerator啦。

佇列

佇列和棧非常相似，只是取資料的方式不同。就是名字看到的那種，排隊用的。

關於佇列的實現，無論是構造還是優化，兩點判斷十分重要：隊滿條件和隊空條件。迴圈佇列就是構造利用率最大的兩個條件的做法。
基於陣列的實現如下：

public class ArrayQueue<T> {
    private Object[] storage = null;
    private int size;
    private int head;
    private int tail;

    public ArrayQueue(int size) {
        if (size >= 0) {
            this.size = size;
            head = tail = 0;
            storage = new Object[size];
        } else {
            throw  new RuntimeException("Illegal queue size: " + size);
        }
    }

    public boolean enqueue(T item) {
        if ((tail + 1) % size == head) {
            return false;
        }
        storage[tail] = item;
        tail = (tail + 1) % size;

        return true;
    }

    public T dequeue() {
        if (tail == head) {
            return null;
        }
        T item = (T)storage[head];
        storage[head] = null;
        head = (head + 1) % size;
        return item;
    }
}

（直接丟程式碼好像很沒意思耶，那下次丟bug吧~）

阻塞佇列和併發佇列

四月份接觸到的一個專案：客戶端需要呼叫服務端的介面（Thrift……如果我表示出了鄙視，可能是因為我對Thrift用法有什麼誤解）進行計算，一般情況下單個計算的時間在1~15分鐘不等，客戶端需要處理多個併發計算請求。當時使用了執行緒池，面臨的問題是，服務端計算失敗或者由於計算方法（計算髮起人編輯）導致計算時間超長的情況時，服務端沒有任何反饋（團隊一致認為這個很正常……），此時客戶端就會面臨執行緒池被佔滿需要進行排隊的情況。
排隊佇列要怎麼處理可能很快就被塞滿的情況，對於生產者和消費者效率協調問題，想起來昨天看的一個段子：

藝術是對特定現實的抽象？

專欄作者給出的一個建議是：多配置幾個消費者

那在服務端已經是分散式計算（用的Akka）的情況下，是否算多個消費者呢？

遞迴

大概是第一次用遞迴的時候就用對了，所以常常自信心滿滿地講：這都不是事~（不要lian
專欄作者對遞迴的幾個總結的超好呢~

遞迴需要滿足的三個條件
  • 一個問題可以分解成幾個子問題的解
  • 這個問題和分解之後的子問題，除了資料規模不同，求解思路完全一樣
  • 存在遞迴終止條件
寫遞迴程式碼的關鍵
  • 找到大問題化小問題的規律
  • 基於規律寫遞推公式
  • 推敲終止條件
  • 翻譯以上步驟
遞迴時如何避免堆疊溢位
  • 限制遞迴深度
int depth = 0;
int f() {
	++depth;
	if (depth > N) throw new RuntimeException();
}

適用場景：最大深度比較小。

如何避免遞迴中的重複計算

使用資料結構來儲存已經計算過的結果。

髒資料產生的無限遞迴問題

環的檢測。連結串列中也有環的檢測？

相關推薦

資料結構與演算法之美專欄學習筆記-排序(上）

排序方法 氣泡排序、插入排序、選擇排序、快速排序、歸併排序、計數排序、基數排序、桶排序。   複雜度歸類 氣泡排序、插入排序、選擇排序 O(n^2) 快速排序、歸併排序 O(nlogn) 計數排序、基數排序、桶排序 O(n)     演算法的執行效率 1. 最

資料結構與演算法之美專欄學習筆記-排序(下）

分治思想 分治思想 分治，顧明思意就是分而治之，將一個大問題分解成小的子問題來解決，小的子問題解決了，大問題也就解決了。 分治與遞迴的區別 分治演算法一般都用遞迴來實現的。分治是一種解決問題的處理思想，遞迴是一種程式設計技巧。   歸併排序 演算法原理 歸併的思想 先把陣列從中間分

資料結構與演算法之美專欄學習筆記-線性排序

線性排序 線性排序的概念 線性排序演算法包括桶排序、計數排序、基數排序。 線性排序演算法的時間複雜度為O(n)。 線性排序的特點 此3種排序演算法都不涉及元素之間的比較操作，是非基於比較的排序演算法。 對排序資料的要求很苛刻，重點掌握此3種排序演算法的適用場景。   桶排序 演算法

資料結構與演算法之美專欄學習筆記-排序優化

選擇合適的排序演算法 回顧   選擇排序演算法的原則 1）線性排序時間複雜度很低但使用場景特殊，如果要寫一個通用排序函式，不能選擇線性排序。 2）為了兼顧任意規模資料的排序，一般會首選時間複雜度為O(nlogn)的排序演算法來實現排序函式。 3）同為O(nlogn)的快排和歸併排序相比，

資料結構與演算法之美專欄學習筆記-陣列

什麼是陣列 陣列（Array）是一種線性表資料結構。它用一組連續的記憶體空間，來儲存一組具有相同型別的資料。 線性表 線性表就是資料排成像一條線一樣的結構。 常見的線性表結構：陣列，連結串列、佇列、棧等。 非線性表有：二叉樹、圖、堆等。 連續的記憶體空間和相同型別的資料 優點：兩限制使得

資料結構與演算法之美專欄學習筆記-複雜度分析

複雜度分析 什麼是複雜度分析 資料結構和演算法解決是“如何讓計算機更快時間、更省空間的解決問題”。 因此需從執行時間和佔用空間兩個維度來評估資料結構和演算法的效能。 分別用時間複雜度和空間複雜度兩個概念來描述效能問題，二者統稱為複雜度。 複雜度描述的是演算法執行時間（或佔用空間）與資料規模的增長關係

資料結構與演算法之美專欄學習筆記-二分查詢(下)

四種常見的二分查詢變形問題 查詢第一個值等於給定值的元素 //查詢第一個等於給定值的元素 public static int BSearch2(int[] a, int n, int value){ //定義陣列頭尾索引 int low = 0, high = n - 1;

資料結構與演算法之美專欄學習筆記-跳錶

跳錶的概念 對連結串列建立n級索引，例如每兩個結點提取一個節點到上一層，稱之為索引層。 圖中的down表示down指標，指向下一級結點   跳錶的時間複雜度 跳錶的高度 跳錶的高度是log2n。 跳錶的時間複雜度 跳錶中查詢某個資料的時間複雜度是O(logn)。  

資料結構與演算法之美專欄學習筆記-雜湊演算法

雜湊演算法的定義和原理 將任意長度的二進位制串對映為固定長度的二進位制串。 這個對映的規則就是雜湊演算法，而通過原始資料對映之後得到的二進位制串就是雜湊值。 設計一個優秀的雜湊演算法需要滿足： 從雜湊值不能反向推匯出原始資料（所以雜湊演算法也叫單向雜湊演算法）； 對輸入資料非常敏感，哪怕原始

資料結構與演算法之美專欄學習筆記-二叉樹基礎(上）

樹 節點的定義 樹中的元素稱之為節點 高度的定義 節點的高度：節點到葉子節點的最長路徑 樹的高度：跟節點的高度 深度的定義 根節點到這個節點所經歷的邊的個數 層的定義 節點的深度+1   二叉樹 滿二叉樹 除了葉子結點外每個節點都有左右兩個子節點 完全二叉樹 葉子結

資料結構與演算法之美專欄學習筆記-二叉樹基礎(下）

二叉查詢樹 Binary Search Tree  二叉查詢樹的定義 二叉查詢樹又稱二叉搜尋樹。其要求在二叉樹中的任意一個節點，其左子樹中的每個節點的值，都要小於這個節點的值，而右子樹的節點的值都大於這個節點的值。 二叉查詢樹的查詢操作 二叉樹類、節點類以及查詢方法的程式碼實現

《資料結構與演算法之美》專欄閱讀筆記5——散列表和雜湊函式

這應該是看完最呆（沒有想到的那種呆~）的一個小章節了，給作者鼓掌，講的好好。果然抽象能力才是王道 文章目錄 1、散列表 1.1、小概念 1.2、雜湊函式 1

《資料結構與演算法之美》專欄閱讀筆記4——二分查詢

找呀找呀找朋友 文章目錄 1、二分查詢 2、變形的二分查詢 2.1、查詢第一個、最後一個值等於給定值的元素 2.2、查詢第一個大於等於、最後一個小於等於給定值

《資料結構與演算法之美》專欄閱讀筆記3——排序演算法

上週排計劃，說花個一天的時間看完好了（藐視臉）~然後每天回家看一會，看了一個星期……做人，要多照鏡子好嘛 文章目錄 1、簡單排序 1.1 如何分析排序演算法

《資料結構與演算法之美》專欄閱讀筆記2——線性表

換個方式來寫筆記，最近啃完了《Thinking in Java》，想要在看專欄的時候多做點擴充套件性的東西，比如把難撩的泛型加進來做實現，程式碼還是要寫起來才曉得怎麼寫更酷。總之最近看書的過程中、搜尋答案的過程中發出了很多“哇~超厲害！超酷！我也要這樣棒棒噠！”的嘆聲。新的開始，

《資料結構與演算法之美》專欄閱讀筆記1——複雜度分析

蹭可愛的男朋友買的極客時間的專欄【資料結構與演算法之美】，作者讓大家定個學習的flag。o(￣▽￣)o，好吧，最近喜歡做思維導圖（純粹因為好看！），所以flag就是每篇都要寫讀書筆記咯~ 文章目錄 1、如何抓住重點，系統

《資料結構與演算法之美》專欄閱讀筆記2

換個方式來寫筆記，最近啃完了《Thinking in Java》，想要在看專欄的時候多做點擴充套件性的東西，比如把難撩的泛型加進來做實現，程式碼還是要寫起來才曉得怎麼寫更酷。總之最近看書的過程中、搜尋答案的過程中發出了很多“哇~超厲害！超酷！我也要這樣棒棒噠！

資料結構與演算法之美 課程筆記二 複雜度分析（上）

資料結構和演算法本身解決的是“快”和“省”的問題，即如何讓程式碼執行得更快，如何讓程式碼更省空間。所以，執行效率是演算法一個非常重要的考量指標。衡量演算法的執行效率最常用的就是時間和空間複雜度分析。 一、為什麼需要複雜度分析？ 把程式碼跑一遍，通過統計、監控來得到演算法執行的時間和佔用的記憶

資料結構與演算法之美 課程筆記一 如何抓住重點，系統高效地學習資料結構與演算法？

什麼是資料結構？什麼是演算法？ 從廣義上講，資料結構就是指一組資料的儲存結構。演算法就是操作資料的一種方法。 從狹義上講，是指某些著名的資料結構和演算法，比如佇列、棧、堆、二分查詢、動態規劃等。 那資料結構和演算法有什麼關係呢？ 資料結構和演算法是相輔相成的。資料結構是為演算法服務的

《資料結構與演算法之美》- 棧

《資料結構與演算法之美》- 棧 棧，在這裡說的是一種資料結構。 你還可能知道的棧 提到“棧”，做Java的同學還會想起Java記憶體模型中的“棧”，與之緊密關聯的還有一個名詞——堆，但是這裡，此棧非彼棧。 引用《深入理解Java虛擬機器》中有關棧的介紹 經常有人把Java