本文共 1962 字，大约阅读时间需要 6 分钟。

链表反转是操作链表的一种常见问题，涉及复杂的指针操作和内部节点的调整。在此问题中，我们不仅需要将链表反转，还需要在原地完成操作（in-place），并且只能遍历链表一次。以下将详细介绍实现方法和步骤。

方法思路

代码实现

#include 
   
    
 struct ListNode {
     int val;
     ListNode* next;
     ListNode(int _val) { val = _val; }
 };
 class Solution {
     public:
         ListNode* reverse(ListNode* head, int m, int n) {
             ListNode dummy(-1);
             dummy.next = head;
             ListNode* prev = &dummy;
             // 迭代m-1次至目标节点
             for (int i = 0; i < m - 1; ++i) {
                 prev = prev->next;
             }
             ListNode* target = prev->next;
             prev->next = NULL;
             // 从目标节点开始逆向构建链表
             for (int i = m; i < n; ++i) {
                 ListNode* next_node = target->next;
                 target->next = prev;
                 prev->next = next_node;
                 prev = target;
                 target = next_node;
             }
             return dummy.next;
         }
         void show(ListNode* ln) {
             for (; ln != NULL; ln = ln->next) {
                 printf("%d\n", ln->val);
             }
         }
         int main() {
             ListNode l1(1), l2(2), l3(3), l4(4);
             l1.next = &l2;
             l2.next = &l3;
             l3.next = &l4;
             l4.next = NULL;
             Solution so;
             ListNode* ad = so.reverse(&l1, 1, 4);
             so.show(ad);
             return 0;
         }
 };
   

解释步骤

示例结果

输入链表：1 -> 2 -> 3 -> 4 -> 5 -> NULL

该方法通过一次遍历完成链表反转，且空间复杂度为O(1)，是空间高效的解决方案。