LeetCode 206. Reverse Linked List

最新推荐文章于 2025-02-10 23:45:56 发布

原创最新推荐文章于 2025-02-10 23:45:56 发布 · 1.3w 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#LeetCode #Linked List #数据结构

C++ 同时被 2 个专栏收录

25 篇文章

订阅专栏

算法与数据结构

19 篇文章

订阅专栏

本文详细介绍了如何通过迭代和递归的方式逆置单链表。提供了清晰的代码示例及步骤解析，帮助读者理解每一步操作的具体含义。

206. Reverse Linked List
Reverse a singly linked list.
Hint:
A linked list can be reversed either iteratively or recursively. Could you implement both?

题意：逆置一个单链表。
提示：您能否使用迭代和递归两种方法？

/*  
    这个题我们可以利用三个指针：
    NULL 1 -> 2 -> 3 -> 4 -> 5
     ↑   ↑↑
     a   bc

    (1)c = b->next;               (2)b->next = a;               (3)a = b;                     (4)b = c;
    NULL 1 -> 2 -> 3 -> 4 -> 5    NULL <- 1  2 -> 3 -> 4 -> 5   NULL <- 1  2 -> 3 -> 4 -> 5   NULL <- 1  2 -> 3 -> 4 -> 5
     ↑   ↑    ↑                    ↑      ↑  ↑                         ↑↑  ↑                          ↑  ↑↑
     a   b    c                    a      b  c                         ab  c                          a  bc

    (1)c = b->next;               (2)b->next = a;               (3)a = b;                     (4)b = c;
    NULL <- 1  2 -> 3 -> 4 -> 5    NULL <- 1 <- 2  3 -> 4 -> 5   NULL <- 1 <- 2  3 -> 4 -> 5   NULL <- 1 <- 2  3 -> 4 -> 5
            ↑  ↑    ↑                      ↑    ↑  ↑                         ↑↑  ↑                          ↑  ↑↑
            a  b    c                      a    b  c                         ab  c                          a  bc     

    (1)c = b->next;               (2)b->next = a;               (3)a = b;                     (4)b = c;                  
    NULL <- 1 <- 2  3 -> 4 -> 5   NULL <- 1 <- 2 <- 3  4 -> 5    NULL <- 1 <- 2 <- 3  4 -> 5   NULL <- 1 <- 2 <- 3  4 -> 5
                 ↑  ↑    ↑                     ↑    ↑  ↑                          ↑↑  ↑                          ↑  ↑↑
                 a  b    c                     a    b  c                          ab  c                          a  bc          

    (1)c = b->next;               (2)b->next = a;               (3)a = b;                     (4)b = c;                  
    NULL <- 1 <- 2 <- 3  4 -> 5   NULL <- 1 <- 2 <- 3 <- 4  5    NULL <- 1 <- 2 <- 3 <- 4  5   NULL <- 1 <- 2 <- 3 <- 4  5
                      ↑  ↑    ↑                     ↑    ↑  ↑                          ↑↑  ↑                          ↑  ↑↑
                      a  b    c                     a    b  c                          ab  c                          a  bc  

    (1)c = b->next;               (2)b->next = a;               (3)a = b;                      (4)b = c;     
    NULL <- 1 <- 2 <- 3 <- 4  5   NULL <- 1 <- 2 <- 3 <- 4 <- 5  NULL <- 1 <- 2 <- 3 <- 4 <- 5  NULL <- 1 <- 2 <- 3 <- 4 <- 5
                           ↑  ↑ ↑                        ↑    ↑ ↑                           ↑↑ ↑                            ↑  ↑↑
                           a  b c                        a    b c                           ab c                            a  bc  

*/

ListNode* reverseList(ListNode* head) {
    if(head == NULL || head -> next == NULL) 
        return head;

    ListNode* first = NULL;
    ListNode* second = head;
    while(second != NULL){
        ListNode* third = second -> next;
        second -> next = first;
        first = second;
        second = third;
    }
    return first;
}

// 使代码更简洁，将参数名改为second
ListNode* reverseList(ListNode* second) {
    ListNode* first = NULL;
    while(second){
        ListNode* third = second -> next;
        second -> next = first;
        first = second;
        second = third;
    }
    return first;
}

下面我们考虑递归的方法：

/*  例如：
    1 -> 2 -> 3 -> 4 -> 5

    1. 1 -> 2 -> 3 -> 4 <- 5
    递归到最深处为 head = 5，返回后到 head = 4 处:
    newHead = 5;
    newTail = 4 -> next = 5;
    5 -> next = 4;
    4 -> next = NULL;
    return 5;

    2. 1 -> 2 -> 3 <- 4 <- 5
    从 head = 4 返回到 head = 3 处
    newHead = 5;
    newTail = head(3) -> next = 4;
    newTail(4) -> next = head(3);
    3 -> next = NULL;
    return 5;

    3. 1 -> 2 <- 3 <- 4 <- 5
    从 head = 3 返回到 head = 2处
    newHead = 5;
    newTail = head(2) -> next = 3;
    newTail(3) -> next = head(2);
    head(2) -> next = NULL;
    return 5;

    ...
-*/

ListNode* reverseList(ListNode* head) {
    if(head == NULL || head -> next == NULL) 
        return head;

    ListNode* newHead = reverseList(head -> next);  // 逆置head -> next作为新的头
    ListNode* newTail = head -> next;               // 新的尾节点为head -> next
    newTail -> next = head;                         // 将该节点逆置
    head -> next = NULL;
    return newHead;  // 返回新的头结点
}