連結串列專題

1、連結串列

連結串列有單連結串列，雙連結串列，環形連結串列；連結串列主要功能是將離散的地址通過指標連線起來。

2、模板

連結串列相對比較靈活，無具體的模板可以套用；可以考慮如下幾點

2.1、新建連結串列時，可以引入一個哨兵節點head=Node(-1)，返回head.next；簡化操作

2.2、環、刪除第k個節點，均可使用快慢指標

3.3、修改下一個指向時，先備份，以免節點丟失

3、例項

19. 刪除連結串列的倒數第N個節點

難度：中等

題目描述

給定一個連結串列，刪除連結串列的倒數第 n 個節點，並且返回連結串列的頭結點。

示例 1:

給定一個連結串列: 1->2->3->4->5, 和 n = 2.

當刪除了倒數第二個節點後，連結串列變為 1->2->3->5.

說明：

給定的 n 保證是有效的。

解題思路

1. 快慢指標
2. 刪除後，空指標問題。

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        
        # 防止，刪除變為空指標。
        _ = ListNode(0)
        _.next = head

        # 快慢指標。
        slow, fast = _ , _
        # 快指標，後移n個節點。
        for i in range(n):
            fast = fast.next
        # 同時移動快慢指標。當快指標到末尾時，慢指標正好在倒數第n-1個節點位置。
        while (fast is not None) and (fast.next is not None) :
            fast = fast.next
            slow = slow.next
        # 刪除目標節點
        slow.next =  slow.next.next

        return _.next

24. 兩兩交換連結串列中的節點

難度：中等

題目描述

給定一個連結串列，兩兩交換其中相鄰的節點，並返回交換後的連結串列。

你不能只是單純的改變節點內部的值，而是需要實際的進行節點交換。

示例:

給定 1->2->3->4, 返回 2->1->4->3.

class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        dummyHead = ListNode(0)
        dummyHead.next = head
        temp = dummyHead
        while temp.next and temp.next.next:
            node1 = temp.next
            node2 = temp.next.next
            temp.next = node2
            node1.next = node2.next
            node2.next = node1
            temp = node1
        return dummyHead.next

https://leetcode-cn.com/problems/swap-nodes-in-pairs/solution/liang-liang-jiao-huan-lian-biao-zhong-de-jie-di-91/

25. K 個一組翻轉連結串列

難度：中等

題目描述

給你一個連結串列，每 k 個節點一組進行翻轉，請你返回翻轉後的連結串列。

k 是一個正整數，它的值小於或等於連結串列的長度。

如果節點總數不是 k 的整數倍，那麼請將最後剩餘的節點保持原有順序。

示例:

給你這個連結串列：1->2->3->4->5

當 k = 2 時，應當返回: 2->1->4->3->5

當 k = 3 時，應當返回: 3->2->1->4->5

class Solution:
    # 翻轉一個子連結串列，並且返回新的頭與尾
    def reverse(self, head: ListNode, tail: ListNode):
        prev = tail.next
        p = head
        while prev != tail:
            nex = p.next
            p.next = prev
            prev = p
            p = nex
        return tail, head

    def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
        hair = ListNode(0)
        hair.next = head
        pre = hair

        while head:
            tail = pre
            # 檢視剩餘部分長度是否大於等於 k
            for i in range(k):
                tail = tail.next
                if not tail:
                    return hair.next
            nex = tail.next
            head, tail = self.reverse(head, tail)
            # 把子連結串列重新接回原連結串列
            pre.next = head
            tail.next = nex
            pre = tail
            head = tail.next
        
        return hair.next

https://leetcode-cn.com/problems/reverse-nodes-in-k-group/solution/k-ge-yi-zu-fan-zhuan-lian-biao-by-leetcode-solutio/