代码随想录算法训练营day03 | 203.移除链表元素， 206.翻转链表， 24. 两两交换链表中的节点

203.移除链表元素

力扣

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
 

示例 1：

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1
输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]

思路：

1、数据结构：单链表

2、算法：双指针 、 虚拟头结点

3、步骤：

a.先建立虚拟头结点dummy_head

b.双指针遍历链表，cur在前，prev在后

c.若 cur.val == val, 则 prev.next = cur.next

d.若 cur.val != val, 则prev =cur, cur = cur.next(双指针前进一位)

e.返回 dummy_head.next 

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy_head = ListNode(-1, head)
        prev = dummy_head
        cur  = head

        while cur:
            if cur.val == val:
                cur = cur.next
                prev.next = cur
            else:
                prev = cur
                cur = cur.next
        
        return dummy_head.next

 206.反转链表

力扣

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

思路:

1、数据结构：链表

2、算法：双指针

3、步骤：

a. prev = None, cur = head

b. 双指针遍历链表，将每一个cur 的 指针指向prev

c. 直到 cur = None, 返回 prev

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        cur = head   
        prev = None
        while cur:
            temp = cur.next # 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur.next = prev #反转
            #更新prev、cur指针
            prev = cur
            cur = temp
        return prev

24. 两两交换链表中的节点

力扣

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：
输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

思路：

1、数据结构：链表

2、算法：虚拟头结点、三指针（cur 为 主指针）

3、步骤：

a.先建立 dummy_head = ListNode(head)

b. cur 指针先指向dummy_head

c. 当 cur 后的两个节点都不为 None 时循环继续

d. 考虑到是两两交换节点，故每次移动cur，只处理cur 后的两个节点

e. a 和 b 两个指针指向 cur 后的两个节点，进行交换，注意与后续节点保持连接

f. 返回dummy_head.next

class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        dummy_head = ListNode(next=head)
        cur = dummy_head
        
        # 必须有cur的下一个和下下个才能交换，否则说明已经交换结束了
        while cur.next and cur.next.next:
            a = cur.next
            b = a.next

            #关键在于断键与链接的先后顺序
            #先连 cur --> b, 再连 a --> b.next, 最后连 b.next = a
            cur.next = b
            a.next = b.next
            b.next = a
            cur = a

        return dummy_head.next