LeetCode-Reverse Linked List

继续一道链表的算法题，运用笨笨的方法实现了（不过却是8ms，不可思议）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == NULL) return NULL;
        else if(head->next == NULL) return head;
        else if(head->next->next == NULL)
        {
            head->next->next = head;
            head = head->next;
            head->next->next = NULL;
            return head;
        }
        else
        {
            ListNode *a, *b, *c, *pre, *current;
            pre = head->next;
            current = pre->next;
            a = pre;
            b = current;
            c = current->next;
            pre->next = head;
            head->next = NULL;
            while(current->next != NULL)
            {

                c = current->next;
                current->next = a;
                a = b;
                b = c;
                current = c;
            }
            current->next = a;
            head = b;
            return head;
        }
    }
};

然后找大神的博客看，发现了别人家的代码
（1）非递归版

//Runtime:10 ms
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == NULL) return NULL;
        ListNode *pre = head;
        ListNode *cur = head->next;
        while (cur != NULL)
        {
            pre->next = cur->next;
            cur->next = head;
            head = cur;
            cur = pre->next;
        }

        return head;
    }
};

此外还发现了用递归实现的更强版本（递归思想：层层进入最后一个节点，然后把前节点的指针付给后节点的指针）
（2）递归版本

//Runtime:10 ms
class Solution{
public:
    ListNode* reverseList(ListNode* head){
        //此处的条件不能写成if(head == NULL)
        if (head == NULL || head->next == NULL) return head;
        ListNode *newhead = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;

        return newhead;
    }
};

本题用的递归实现要求记住