LintCode 35: Reverse Linked List (最基本最经典的链表反转题)

关于链表反转有几种做法：
解法1：比较简洁，思路是把链表节点按prev-head-temp的顺序依次递增，直到最后的NULL。
注意：
1）这个写法最简洁好记。temp, head->next, prev, head, temp 按顺序下来。
2）切记不要画蛇添足加上
temp->next=head;
这样head->next链表就过不来了。
3) 最后返回prev。
4) 注意这里千万不要用dummy head，最后返回dummy->next。因为dummy是相当于一开始的pre，最后dummy->next就是NULL。

/**
 * Definition of singly-linked-list:
 *
 * class ListNode {
 * public:
 *     int val;
 *     ListNode *next;
 *     ListNode(int val) {
 *        this->val = val;
 *        this->next = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param head: n
     * @return: The new head of reversed linked list.
     */
    ListNode * reverse(ListNode * head) {
        ListNode *prev = NULL;
        
        while(head) {
           ListNode *temp = head->next;
           head->next = prev;
           prev = head;
           head = temp;
        }
        
        return prev;
    }
};

解法2：3指针法。比较经典。
对比解法1可以知道两种方法等价：
p1 <-> prev
p2 <-> head
p3 <-> temp

class Solution {
public:
    /**
     * @param head: n
     * @return: The new head of reversed linked list.
     */
    ListNode * reverse(ListNode * head) {
        ListNode *p1, *p2, *p3;
        
        if (!head || !head->next) return head;
        
        p1 = head; 
        p2 = p1->next;
        
        while(p2) {
            p3 = p2->next;
            p2->next = p1;
            p1 = p2;
            p2 = p3;
        }
        
        head->next = NULL;
        head = p1;
        return head;
    }
};

解法3：通过stack压栈来反转。
下次再做。

解法4：通过递归也可以。
版本1:

class Solution {
public:
    /**
     * @param head: n
     * @return: The new head of reversed linked list.
     */
    ListNode * reverse(ListNode * head) {
        if (!head || !head->next) return head;
        ListNode * node = reverse(head->next);
        head->next->next = head;
        head->next = NULL;
        return node;
    }
};

写成这样也可以：

class Solution {
public:
    ListNode* reverseList(ListNode* head) { //反转整个链表
        if (head == nullptr || head->next == nullptr) return head;
        ListNode *tail = head->next, *p = reverseList(head->next);
        head->next = tail->next; // 这里是反转整个链表，写成head->next = nullptr; 也可以。但如果是反转部分链表，比如LintCode 36就不能这么写了。
        tail->next = head;
        return p;   
    }
};

版本2：

class Solution {
public:
    /**
     * @param head: n
     * @return: The new head of reversed linked list.
     */
    ListNode * reverse(ListNode * head) {
        if (!head || !head->next) return head;
        ListNode * node = dfs(head);
        head->next = NULL;
        return node;
    }
private:
    ListNode * dfs(ListNode * head) {
        if (!head || !head->next) return head;
        ListNode * node = dfs(head->next);
        head->next->next = head;
        return node;
    }
};