LeetCode 206. Reverse Linked List

原题链接在这里：https://leetcode.com/problems/reverse-linked-list/

题目：

Reverse a singly linked list.

题解：

Iteration 方法：

生成tail = head, cur = tail, while loop 的条件是tail.next != null. 最后返回cur 就好。

Time Complexity: O(n).

Space O(1).

AC Java: 

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null){
            return head;
        }
        ListNode tail = head;
        ListNode cur = head;
        ListNode pre;
        ListNode temp;
        while(tail.next != null){
            pre = cur;
            cur = tail.next;
            temp = cur.next;
            cur.next = pre;
            tail.next = temp;
        }
        return cur;
    }
}

AC JavaScript:

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
    if(!head || !head.next){
        return head;
    }
    
    var tail = head;
    var cur = tail;
    var pre = null;
    var temp = null;
    while(tail.next){
        pre = cur;
        cur = tail.next;
        temp = cur.next;
        cur.next = pre;
        tail.next = temp;
    }
    
    return cur;
};

AC C++:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(!head || !head->next){
            return head;
        }

        ListNode *tail = head;
        ListNode *cur = head;
        ListNode *pre;
        ListNode *temp;
        while(tail->next){
            pre = cur;
            cur = tail->next;
            temp = cur->next;
            cur->next = pre;
            tail->next = temp;
        }

        return cur;
    }
};

AC Python:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:
            return head
        
        tail = cur = head
        pre = temp = None
        while(tail.next):
            pre = cur
            cur = tail.next
            temp = cur.next
            cur.next = pre
            tail.next = temp
        
        return cur

Recursion 方法:

reverseList(head.next)返回的是从head.next开始的reverse list，把head加在他的尾部即可。

他的尾部恰巧是之前的head.next, 这里用nxt表示。

Recursion 终止条件是head.next == null, 而不是head == null, head==null只是一种corner case而已。

Time Complexity: O(n), 先下去再回来一共走两遍.

Space O(n), 迭代用了stack一共O(n)大小, n 是原来list的长度。

AC Java:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode reverseList(ListNode head) {
        //Method: Recursion
        if(head == null || head.next == null){
            return head;
        }
        
        ListNode nxt = head.next;
        ListNode newHead = reverseList(nxt);
        
        nxt.next = head;
        head.next = null;
        return newHead;
    }
}

跟上Reverse Linked List II, Reverse Nodes in k-Group, Binary Tree Upside Down, Palindrome Linked List, Maximum Twin Sum of a Linked List.