[算法学习08] 一些链表题

1. 237. 删除链表中的节点 https://leetcode.cn/problems/delete-node-in-a-linked-list/solutions/2004056/ru-he-shan-chu-jie-dian-liu-fen-zhong-ga-x3kn/

解题思路

脑筋急转弯.

直接用后一个节点的值覆盖当前的节点，然后删除后一个节点即可。

如果我们要删除某个节点，那么必须有它的前驱节点。这题没有，所以可以通过值得转移来完成。

以下是代码。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def deleteNode(self, node):
        """
        :type node: ListNode
        :rtype: void Do not return anything, modify node in-place instead.
        """
        node.val = node.next.val
        node.next = node.next.next 

2. 19. 删除链表的倒数第 N 个结点 https://leetcode.cn/problems/remove-nth-node-from-end-of-list/solutions/2004057/ru-he-shan-chu-jie-dian-liu-fen-zhong-ga-xpfs/

解题思路：

准备两个指针，一个先走n-1步后另一个再走。

第一个指针走到了终点，另一个正好是n-1个节点，也就是我们要删除得前驱节点。

因为有可能要删除head，所以我们还要准备一个dummy在head之前。

代码如下：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        if head is None:
            return head 
        dummy = fast = slow = ListNode(next = head)
        for _ in range(n):
            fast = fast.next 

        while fast.next:
            fast = fast.next 
            slow = slow.next 
        slow.next = slow.next.next 
        return dummy.next 

3. 83. 删除排序链表中的重复元素 https://leetcode.cn/problems/remove-duplicates-from-sorted-list/solutions/2004062/ru-he-qu-zhong-yi-ge-shi-pin-jiang-tou-p-98g7/

解题思路：

简单题，链表有序，去重。

只需要判断下一个元素是否和当前元素相同，相同的话删除即可。不同的话则移动到下一个节点。

代码如下：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        p = head
        while p and p.next:
            if p.val == p.next.val:
                p.next = p.next.next 
                continue
            p = p.next 
        return head 

4. 删除排序链表中的重复元素 II https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii/solutions/2004067/ru-he-qu-zhong-yi-ge-shi-pin-jiang-tou-p-2ddn/

解题思路：

这次是只要重复就删除。

例如，1 1 1 2 3 -> 2 3 。

所以我们应该设置一个虚拟头节点dummy，这是考虑到有可能删除头节点。

cur用来存当前的节点，也是以这个视角看后面两个节点。

if cur.next.val == cur.next.next.val：

        说明重复了，可以通过循环把重复的节点全部删除。

        用一个临时节点val存cur.next的值，然后循环遍历删除即可。

以下是代码

class Solution:  
    def deleteDuplicates(self, head: ListNode) -> ListNode:  
        cur = dummy = ListNode(next=head)  
        while cur.next and cur.next.next:
            val = cur.next.val   
            if cur.next.next.val == val:
                while cur.next and cur.next.val == val:
                    cur.next = cur.next.next 
            else:
                cur = cur.next 
          
        return dummy.next

5. 203. 移除链表元素 https://leetcode.cn/problems/remove-linked-list-elements/

解题思路：

简单题，双指针遍历 pre，cur = dummy，head

if cur.val == val:

        pre.next = cur.next 即可

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy = ListNode(next = head)
        pre, cur = dummy, head
        while cur:
            if cur.val == val:
                pre.next = cur.next  
            else:
                pre = cur
            cur = cur.next 
        return dummy.next