[算法總結] 一文搞懂面試鏈表題

本文首發於我的個人博客：尾尾部落

鏈表是面試過程中經常被問到的，這裏把劍指offer 和 LeetCode 中的相關題目做一個彙總，方便複習。

1. 在 O(1) 時間刪除鏈表節點

題目描述：給定單向鏈表的頭指針和一個節點指針，定義一個函數在O(1)時間刪除該節點。
解題思路：常規的做法是從鏈表的頭結點開始遍歷，找到需要刪除的節點的前驅節點，把它的 next 指向要刪除節點的下一個節點，平均時間複雜度爲O(n)，不滿足題目要求。
那是不是一定要得到被刪除的節點的前一個節點呢？其實不用的。我們可以很方面地得到要刪除節點的下一個節點，如果我們把下一個節點的內容複製到要刪除的節點上覆蓋原有的內容，再把下一個節點刪除，那就相當於把當前要刪除的節點刪除了。舉個栗子，我們要刪除的節點i，先把i的下一個節點j的內容複製到i，然後把i的指針指向節點j的下一個節點。此時再刪除節點j，其效果剛好是把節點i給刪除了。
要注意兩種情況：

1. 如果鏈表中只有一個節點，即頭節點等於要刪除的節點，此時我們在刪除節點之後，還需要把鏈表的頭節點設置爲NULL。
2. 如果要刪除的節點位於鏈表的尾部，那麼它就沒有下一個節點，這時我們就要從鏈表的頭節點開始，順序遍歷得到該節點的前序節點，並完成刪除操作。

參考代碼

public static ListNode deleteNode(ListNode head, ListNode toBeDeleted) {  
    // 如果輸入參數有空值就返回表頭結點  
    if (head == null || toBeDeleted == null) {  
        return head;  
    }  
    // 如果刪除的是頭結點，直接返回頭結點的下一個結點  
    if (head == toBeDeleted) {  
        return head.next;  
    }  
      // 下面的情況鏈表至少有兩個結點  
    // 在多個節點的情況下，如果刪除的是最後一個元素  
    if (toBeDeleted.next == null) {  
        // 找待刪除元素的前驅  
        ListNode tmp = head;  
        while (tmp.next != toBeDeleted) {  
            tmp = tmp.next;  
        }  
        // 刪除待結點  
        tmp.next = null;  
    }  
    // 在多個節點的情況下，如果刪除的是某個中間結點  
    else {  
        // 將下一個結點的值輸入當前待刪除的結點  
        toBeDeleted.value = toBeDeleted.next.value;  
        // 待刪除的結點的下一個指向原先待刪除引號的下下個結點，即將待刪除的下一個結點刪除  
        toBeDeleted.next = toBeDeleted.next.next;  
    }  
    // 返回刪除節點後的鏈表頭結點  
    return head;  
}  

2. 翻轉單鏈表

題目描述：輸出一個單鏈表的逆序反轉後的鏈表。
解題思路：用三個臨時指針 prev、cur、next 在鏈表上循環一遍即可。

[劍指offer] 從尾到頭打印鏈表
[劍指offer] 反轉鏈表

3. 翻轉部分單鏈表：

題目描述：給定一個單向鏈表的頭結點head,以及兩個整數from和to,在單鏈表上把第from個節點和第to個節點這一部分進行反轉

舉例：1->2->3->4->5->null, from = 2, to = 4
結果：1->4->3->2->5->null

public ListNode reverseBetween(ListNode head, int m, int n) {
    if (head == null) return null;
    if (head.next == null) return head;
    int i = 1;
    ListNode reversedNewHead = null;// 反轉部分鏈表反轉後的頭結點
    ListNode reversedTail = null;// 反轉部分鏈表反轉後的尾結點
    ListNode oldHead = head;// 原鏈表的頭結點
    ListNode reversePreNode = null;// 反轉部分鏈表反轉前其頭結點的前一個結點
    ListNode reverseNextNode = null;
    while (head != null) {
        if (i > n) {
            break;
        }
        if (i == m - 1) {
            reversePreNode = head;
        }
        if (i >= m && i <= n) {
            if (i == m) {
                reversedTail = head;
            }
            reverseNextNode = head.next;
            head.next = reversedNewHead;
            reversedNewHead = head;
            head = reverseNextNode;
        } else {
            head = head.next;
        }
        i++;
    }
    reversedTail.next = reverseNextNode;
    if (reversePreNode != null) {
        reversePreNode.next = reversedNewHead;
        return oldHead;
    } else {
        return reversedNewHead;
    }
}

4. 旋轉單鏈表

題目描述：給定一個單鏈表，設計一個算法實現鏈表向右旋轉 K 個位置。
舉例： 給定 1->2->3->4->5->6->NULL, K=3
則4->5->6->1->2->3->NULL
解題思路：

• 方法一 雙指針，快指針先走k步，然後兩個指針一起走，當快指針走到末尾時，慢指針的下一個位置是新的順序的頭結點，這樣就可以旋轉鏈表了。
• 方法二 先遍歷整個鏈表獲得鏈表長度n，然後此時把鏈表頭和尾鏈接起來，在往後走n - k % n個節點就到達新鏈表的頭結點前一個點，這時斷開鏈表即可。

方法二代碼：

public class Solution { {
    public ListNode rotateRight(ListNode head, int k) {
        if (!head) return null;
        int n = 1;
        ListNode cur = head;
        while (cur.next) {
            ++n;
            cur = cur.next;
        }
        cur.next = head;
        int m = n - k % n;
        for (int i = 0; i < m; ++i) {
            cur = cur.next;
        }
        ListNode newhead = cur.next;
        cur.next = NULL;
        return newhead;
    }
};

5. 刪除單鏈表倒數第 n 個節點

題目描述：刪除單鏈表倒數第 n 個節點，1 <= n <= length，儘量在一次遍歷中完成。
解題思路：雙指針法，找到倒數第 n+1 個節點，將它的 next 指向倒數第 n-1個節點。

[劍指offer] 鏈表中倒數第k個結點

6. 求單鏈表的中間節點

題目描述：求單鏈表的中間節點，如果鏈表的長度爲偶數，返回中間兩個節點的任意一個，若爲奇數，則返回中間節點。
解題思路：快慢指針，慢的走一步，快的走兩步，當快指針到達尾節點時，慢指針移動到中間節點。

// 遍歷一次，找出單鏈表的中間節點
public ListNode findMiddleNode(ListNode head) {
    if (null == head) {
        return;
    }
    ListNode slow = head;
    ListNode fast = head;

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

7. 鏈表劃分

題目描述： 給定一個單鏈表和數值x，劃分鏈表使得所有小於x的節點排在大於等於x的節點之前。

public class Solution {
    /**
     * @param head: The first node of linked list.
     * @param x: an integer
     * @return: a ListNode 
     */
    public ListNode partition(ListNode head, int x) {
        // write your code here
        if(head == null) return null;
        ListNode leftDummy = new ListNode(0);
        ListNode rightDummy = new ListNode(0);
        ListNode left = leftDummy, right = rightDummy;

        while (head != null) {
            if (head.val < x) {
                left.next = head;
                left = head;
            } else {
                right.next = head;
                right = head;
            }
            head = head.next;
        }

        right.next = null;
        left.next = rightDummy.next;
        return leftDummy.next;
    }
}

8. 鏈表求和

題目描述：你有兩個用鏈表代表的整數，其中每個節點包含一個數字。數字存儲按照在原來整數中相反的順序，使得第一個數字位於鏈表的開頭。寫出一個函數將兩個整數相加，用鏈表形式返回和。
解題思路：做個大循環，對每一位進行操作：

當前位：(A[i]+B[i])%10
進位：（A[i]+B[i]）/10

public class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode c1 = l1;
        ListNode c2 = l2;
        ListNode sentinel = new ListNode(0);
        ListNode d = sentinel;
        int sum = 0;
        while (c1 != null || c2 != null) {
            sum /= 10;
            if (c1 != null) {
                sum += c1.val;
                c1 = c1.next;
            }
            if (c2 != null) {
                sum += c2.val;
                c2 = c2.next;
            }
            d.next = new ListNode(sum % 10);
            d = d.next;
        }
        if (sum / 10 == 1)
            d.next = new ListNode(1);
        return sentinel.next;
    }
}

9. 單鏈表排序

題目描述：在O(nlogn)時間內對鏈表進行排序。
快速排序：

public ListNode sortList(ListNode head) {
    //採用快速排序
   quickSort(head, null);
   return head;
}
public static void quickSort(ListNode head, ListNode end) {
    if (head != end) {
        ListNode node = partion(head, end);
        quickSort(head, node);
        quickSort(node.next, end);
    }
}

public static ListNode partion(ListNode head, ListNode end) {
    ListNode p1 = head, p2 = head.next;

    //走到末尾才停
    while (p2 != end) {

        //大於key值時，p1向前走一步，交換p1與p2的值
        if (p2.val < head.val) {
            p1 = p1.next;

            int temp = p1.val;
            p1.val = p2.val;
            p2.val = temp;
        }
        p2 = p2.next;
    }

    //當有序時，不交換p1和key值
    if (p1 != head) {
        int temp = p1.val;
        p1.val = head.val;
        head.val = temp;
    }
    return p1;
}

歸併排序：

public ListNode sortList(ListNode head) {
    //採用歸併排序
    if (head == null || head.next == null) {
        return head;
    }
    //獲取中間結點
    ListNode mid = getMid(head);
    ListNode right = mid.next;
    mid.next = null;
    //合併
    return mergeSort(sortList(head), sortList(right));
}

/**
 * 獲取鏈表的中間結點,偶數時取中間第一個
 *
 * @param head
 * @return
 */
private ListNode getMid(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    //快慢指針
    ListNode slow = head, quick = head;
    //快2步，慢一步
    while (quick.next != null && quick.next.next != null) {
        slow = slow.next;
        quick = quick.next.next;
    }
    return slow;
}

/**
 *
 * 歸併兩個有序的鏈表
 *
 * @param head1
 * @param head2
 * @return
 */
private ListNode mergeSort(ListNode head1, ListNode head2) {
    ListNode p1 = head1, p2 = head2, head;
   //得到頭節點的指向
    if (head1.val < head2.val) {
        head = head1;
        p1 = p1.next;
    } else {
        head = head2;
        p2 = p2.next;
    }

    ListNode p = head;
    //比較鏈表中的值
    while (p1 != null && p2 != null) {

        if (p1.val <= p2.val) {
            p.next = p1;
            p1 = p1.next;
            p = p.next;
        } else {
            p.next = p2;
            p2 = p2.next;
            p = p.next;
        }
    }
    //第二條鏈表空了
    if (p1 != null) {
        p.next = p1;
    }
    //第一條鏈表空了
    if (p2 != null) {
        p.next = p2;
    }
    return head;
}

10. 合併兩個排序的鏈表

題目描述：輸入兩個單調遞增的鏈表，輸出兩個鏈表合成後的鏈表，當然我們需要合成後的鏈表滿足單調不減規則。

[劍指offer] 合併兩個排序的鏈表

11. 複雜鏈表的複製

題目描述：輸入一個複雜鏈表（每個節點中有節點值，以及兩個指針，一個指向下一個節點，另一個特殊指針指向任意一個節點），返回結果爲複製後複雜鏈表的head。（注意，輸出結果中請不要返回參數中的節點引用，否則判題程序會直接返回空）

[劍指offer] 複雜鏈表的複製

12. 刪除鏈表中重複的結點

題目描述：在一個排序的鏈表中，存在重複的結點，請刪除該鏈表中重複的結點，重複的結點不保留，返回鏈表頭指針。 例如，鏈表1->2->3->3->4->4->5 處理後爲 1->2->5

[劍指offer] 刪除鏈表中重複的結點

13. 判斷單鏈表是否存在環

題目描述：判斷一個單鏈表是否有環
分析：快慢指針，慢指針每次移動一步，快指針每次移動兩步，如果存在環，那麼兩個指針一定會在環內相遇。

14. 單鏈表是否有環擴展：找到環的入口點

題目描述：判斷單鏈表是否有環，如果有，找到環的入口點
解題思路：在第 5 題兩個指針相遇後，讓其中一個指針回到鏈表的頭部，另一個指針在原地，同時往前每次走一步，當它們再次相遇時，就是在環路的入口點。

[劍指offer] 鏈表中環的入口結點

15. 判斷兩個無環單鏈表是否相交

題目描述：給出兩個無環單鏈表
解題思路：

• 方法一 最直接的方法是判斷 A 鏈表的每個節點是否在 B 鏈表中，但是這種方法的時間複雜度爲 O(Length(A) * Length(B))。
• 方法二 轉化爲環的問題。把 B 鏈表接在 A 鏈表後面，如果得到的鏈表有環，則說明兩個鏈表相交。可以之前討論過的快慢指針來判斷是否有環，但是這裏還有更簡單的方法。如果 B 鏈表和 A 鏈表相交，把 B 鏈表接在 A 鏈表後面時，B 鏈表的所有節點都在環內，所以此時只需要遍歷 B 鏈表，看是否會回到起點就可以判斷是否相交。這個方法需要先遍歷一次 A 鏈表，找到尾節點，然後還要遍歷一次 B 鏈表，判斷是否形成環，時間複雜度爲 O(Length(A) + Length(B))。
• 方法三 除了轉化爲環的問題，還可以利用“如果兩個鏈表相交於某一節點，那麼之後的節點都是共有的”這個特點，如果兩個鏈表相交，那麼最後一個節點一定是共有的。所以可以得出另外一種解法，先遍歷 A 鏈表，記住尾節點，然後遍歷 B 鏈表，比較兩個鏈表的尾節點，如果相同則相交，不同則不相交。時間複雜度爲 O(Length(A) + Length(B))，空間複雜度爲 O(1)，思路比解法 2 更簡單。

方法三的代碼：

public boolean isIntersect(ListNode headA, ListNode headB) {
    if (null == headA || null == headB) {
        return false;
    }
    if (headA == headB) {
        return true;
    }
    while (null != headA.next) {
        headA = headA.next;
    }
    while (null != headB.next) {
        headB = headB.next;
    }
    return headA == headB;
}

16. 兩個鏈表相交擴展：求兩個無環單鏈表的第一個相交點

題目描述：找到兩個無環單鏈表第一個相交點，如果不相交返回空，要求在線性時間複雜度和常量空間複雜度內完成。
解題思路：

• 方法一 如果兩個鏈表存在公共結點，那麼它們從公共結點開始一直到鏈表的結尾都是一樣的，因此我們只需要從鏈表的結尾開始，往前搜索，找到最後一個相同的結點即可。但是題目給出的單向鏈表，我們只能從前向後搜索，這時，我們就可以藉助棧來完成。先把兩個鏈表依次裝到兩個棧中，然後比較兩個棧的棧頂結點是否相同，如果相同則出棧，如果不同，那最後相同的結點就是我們要的返回值。
• 方法二 先找出2個鏈表的長度，然後讓長的先走兩個鏈表的長度差，然後再一起走，直到找到第一個公共結點。
• 方法三 由於2個鏈表都沒有環，我們可以把第二個鏈表接在第一個鏈表後面，這樣就把問題轉化爲求環的入口節點問題。
• 方法四 兩個指針p1和p2分別指向鏈表A和鏈表B，它們同時向前走，當走到尾節點時，轉向另一個鏈表，比如p1走到鏈表 A 的尾節點時，下一步就走到鏈表B，p2走到鏈表 B 的尾節點時，下一步就走到鏈表 A，當p1==p2 時，就是鏈表的相交點

方法四的代碼：

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    if (null == headA || null == headB) {
        return null;
    }
    if (headA == headB) {
        return headA;
    }

    ListNode p1 = headA;
    ListNode p2 = headB;
    while (p1 != p2) {
        // 遍歷完所在鏈表後從另外一個鏈表再開始
        // 當 p1 和 p2 都換到另一個鏈表時，它們對齊了：
        // （1）如果鏈表相交，p1 == p2 時爲第一個相交點
        // （2）如果鏈表不相交，p1 和 p2 同時移動到末尾，p1 = p2 = null，然後退出循環
        p1 = (null == p1) ? headB : p1.next;
        p2 = (null == p2) ? headA : p2.next;
    }
    return p1;
}

[劍指offer] 兩個鏈表的第一個公共結點

17. 兩個鏈表相交擴展：判斷兩個有環單鏈表是否相交

題目描述：上面的問題是針對無環鏈表的，如果是鏈表有環呢？
解題思路：如果兩個有環單鏈表相交，那麼它們一定共有一個環，即環上的任意一個節點都存在於兩個鏈表上。因此可以先用之前快慢指針的方式找到兩個鏈表中位於環內的兩個節點，如果相交的話，兩個節點在一個環內，那麼移動其中一個節點，在一次循環內肯定可以與另外一個節點相遇。