题目描述

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

分析

这是一个经典的链表问题，要求反转链表的部分节点。我们可以通过以下步骤实现：

1. 定位到需要反转的部分的前一个节点。
2. 反转从 left 到 right 之间的节点。
3. 连接反转后的部分与链表的其他部分。

具体的代码实现 (Swift)

class ListNode {
    var val: Int
    var next: ListNode?
    init(_ val: Int) {
        self.val = val
        self.next = nil
    }
}

func reverseBetween(_ head: ListNode?, _ left: Int, _ right: Int) -> ListNode? {
    // 边界条件
    if head == nil || left == right {
        return head
    }
    
    // 创建哑节点，方便处理头节点变更
    let dummy = ListNode(0)
    dummy.next = head
    var prev: ListNode? = dummy
    
    // 移动 prev 到 left 之前的位置
    for _ in 1..<left {
        prev = prev?.next
    }
    
    // 开始反转的起点
    let start = prev?.next
    var then = start?.next
    
    // 反转节点
    for _ in 0..<(right - left) {
        start?.next = then?.next
        then?.next = prev?.next
        prev?.next = then
        then = start?.next
    }
    
    return dummy.next
}

// 辅助函数：打印链表
func printList(_ head: ListNode?) {
    var current = head
    while current != nil {
        print(current!.val, terminator: " ")
        current = current?.next
    }
    print()
}

// 测试用例
let head = ListNode(1)
head.next = ListNode(2)
head.next?.next = ListNode(3)
head.next?.next?.next = ListNode(4)
head.next?.next?.next?.next = ListNode(5)

print("原链表：")
printList(head)

let left = 2
let right = 4

let result = reverseBetween(head, left, right)
print("反转后链表：")
printList(result)

代码解释：

1. 边界条件处理：如果 head 为 nil 或 left 等于 right，直接返回 head，因为不需要反转。
2. 哑节点：创建一个哑节点（dummy node），指向链表的头部，以方便处理头节点变更的情况。
3. 定位到反转起点的前一个节点：使用 prev 指针定位到 left 位置的前一个节点。
4. 反转链表部分节点：通过改变节点的 next 指针，逐步反转 left 到 right 之间的节点。
5. 返回新链表头：反转操作完成后，返回新的链表头，即 dummy.next。

这段代码可以正确地反转链表中指定位置之间的节点，并通过辅助函数 printList 打印链表以验证结果。