算法通关村第二关-指定区间反转与两两交换

一、指定区间反转

1. 问题说明

LeetCode92 反转链表 II
给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表。

 

2. 问题分析

方法1：头插法

思路分析：在需要反转的区间里，每遍历到一个节点，让这个新接单来到反转部分的起始位置

方法2：穿针引线法

 思路分析：
1. 确定需要反转的区间
2. 将需要反转的区间进行反转
3. 再将三段链表拼接起来

 

 

 3. 代码实现python

方法1：头插法

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
        ans = ListNode(-1, head)
        pre = ans
        for _ in range(left-1):
            pre = pre.next

        cur = pre.next
        for _ in range(right-left):
            next = cur.next
            cur.next = next.next
            next.next = pre.next
            pre.next = next
        return ans.next

方法2：穿针引线法

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
        # 内部函数，反转链表
        def reverse_link_list(head):
            pre = None
            cur = head
            while cur:
                next = cur.next
                cur.next = pre
                pre = cur
                cur = next
        
        # 第1步：找到left node的前一个节点 pre
        ans = ListNode(-1, head)
        pre = ans
        for _ in range(left-1):
            pre = pre.next

        # 第2步：找到right node
        right_node = pre
        for _ in range(right-left+1):
            right_node = right_node.next
        
        # 第3步：截取链表(切两刀)
        # 第1刀
        left_node = pre.next
        pre.next = None
        # 第2刀
        curr = right_node.next
        right_node.next = None

        # 第4步：翻转中间截取的链表
        reverse_link_list(left_node)

        # 第5步：接回原来的链表中
        pre.next = right_node
        left_node.next = curr

        return ans.next

二、两两交换

1. 问题说明

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

 2. 问题分析

思路分析：不用考虑太多，相邻节点两两交换
交换前
dummyNode -> node1 -> node2
dummyNode -> dummyNode.next -> dummyNode.next.next
交换后
dummyNode -> node2 -> node1
dummyNode -> dummyNode.next.next -> dummyNode.next

 3. 代码实现

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        ans = ListNode(0, head)
        temp = ans
        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 ans.next