LeetCode 206. Reverse Linked List

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;
newTa
aa5e
il = 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;  // 返回新的头结点
}