反转链表

第一个想到的还是栈，毕竟翻转这种事情。。

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        if(!pHead)
            return NULL;
        stack<ListNode*> s;
        while(pHead)
        {
            s.push(pHead);
            pHead = pHead->next;
        }

        ListNode* root = s.top();   //新头
        ListNode* p = root;    //辅助
        while(!s.empty())
        {
            p->next = s.top();
            p = p->next;
            s.pop();
        }
        p->next = NULL;
        return root;
    }
};

第二种是链表的前插法，取原链表的每一个节点，前插到新的链表上。

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        if(!pHead)
            return NULL;
        ListNode* root = pHead;
        pHead = pHead->next;
        root->next = NULL;
        while(pHead)
        {
            ListNode* next_node = pHead->next;  //保存下一个节点
            pHead->next = root;
            root = pHead;   //新头是新插入的节点
            pHead = next_node;
        }
        return root;
    }
};

第三种是三个指针在链表上滑动，把每个节点指向前一个节点（如果为空则指向NULL）

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        ListNode* pre = NULL;
        ListNode* after = NULL;
        while(pHead)
        {
            after = pHead->next;//保存下个节点
            pHead->next = pre;
            pre = pHead;
            pHead = after;
        }
        return pre;
    }
};

还有第四种，递归。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(!head || !head->next)
            return head;

        ListNode* newhead = reverseList(head->next);
        head->next->next = head;  //1
        head->next = NULL;  //2
        return newhead;

    }
};

上边的1、2可以这样理解：
反转链表的最底结构可以为两个节点，