描述

輸入一個連結串列，反轉連結串列後，輸出新連結串列的表頭。

演算法

1. 因為連結串列結尾是 null，所以讓 pre 的值是 null, p 就表示我們的頭部
   

2. 因為 p 的 next 成員馬上就要指向 pre, 如果不儲存 p 的下一個節點就會使其丟失，所以通過臨時變數 t 儲存它
   

3. 讓 P 的 next 成員指向 pre
   

4. pre 移動到 p 的位置，p 移動到 t 的位置，此時我們就回到了第一步中的情況
   

5. 保持這個迴圈不變式直到 p 移動到原連結串列結尾我們就獲得了翻轉之後的連結串列。

// c++
class Solution {
public:
    ListNode* ReverseList(ListNode* p) {
        ListNode* pre = nullptr;
        while (p) {
            ListNode* t = p->next;
            p->next = pre;
            pre = p;
            p = t;
        }
        return pre;
    }
};
 

# python3
class Solution:
    # 返回ListNode
    def ReverseList(self, pHead):
        # write code here
        pre = None
        cur = pHead
        while cur:
            tmp = cur.next
            cur.next = pre 
            pre = cur 
            cur = tmp 
        return pre

遍歷一次連結串列，時間複雜度是 O(n)，空間複雜度是 O(1)。

另一種解法

如果上面的方法不便於理解，我們可以用陣列把連結串列的每個元素都儲存下來，翻轉之後再重建連結串列，不過不推薦這種做法，它的時間複雜度是 O(n)， 空間複雜度是 O(n)。

// c++
class Solution {
public:
    ListNode* ReverseList(ListNode* p) {
        if (!p) return p;
        vector<ListNode*> res;
        for (; p; p = p->next) {
            res.emplace_back(p);
        }
        reverse(res.begin(), res.end());
        for (int i = 0; i < res.size() - 1; i++) {
            res[i]->next = res[i + 1];
        }
        res[res.size() - 1]->next = nullptr;
        return res[0];
    }
};
 

# python3
class Solution:
    # 返回ListNode
    def ReverseList(self, p):
        # write code here
        if not p: return p 
        res = []
        while p:
            res.append(p)
            p = p.next
        res = list(reversed(res))
        for i in range(len(res) - 1):
            res[i].next = res[i + 1]
        res[-1].next = None
        return res[0]