剑指 Offer 24. 反转链表

题目描述：

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
 

限制：

0 <= 节点个数 <= 5000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析：第一眼看到这个题，想到的最暴力的解法，一次遍历，找到最后一个节点，设置为新链表的第一个节点，再次遍历链表，找到倒数第二个，设置为第二个。。。以此类推，但是时间复杂度为O（n*n），显然不妥。

于是，想到了第二种办法 ：对链表遍历一次，每次遍历到节点时，把节点插入到head1节点的后一个节点，并把之前head1节点的链接断开。举例如下：

原链表：1->2->3->4->5->null

新链表：

head1->1

head1->2->1

head1->3->2->1

head1->4->3->2->1

head1->5->4->3->2->1

即每次断开后续的节点，插入新节点，代码如下：

/**
 * 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) {
        ListNode *p=head;
        ListNode *head1=new ListNode(0);
        while(p!=NULL)
        {
            ListNode *now=new ListNode(p->val);
            if(head1->next!=NULL)
            {
                ListNode *temp=head1->next;
                head1->next=now;
                now->next=temp;
            }
            else
            {
                head1->next=now;
            }
            p=p->next;
            
        }
        return head1->next;

    }
};

但是这种方法开辟了新的空间，如何不开辟新空间完成这一步呢？想半天想不出来，就只有看看题解了。

题解的思路，遍历链表的时候，把next指向前一个节点，这样遍历到最后一个节点的时候，就是新链表的头节点。但是要保存链接断开前的下一个节点。代码如下：

/**
 * 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) {
        ListNode *cur=head;
        ListNode *pre=NULL;

        while(cur!=NULL)
        {
            // 断开连接前，要保存一下cur->next，不然断开连接后就找不到了
            ListNode *temp=cur->next;
            // 把cur->next设置为上一个节点
            cur->next=pre;
            // pre前移到当前节点
            pre=cur;
            // 当前节点前移到下一个节点
            cur=temp;
        } 
        // 返回pre，pre现在是新链表的头节点，cur为NULL
        return pre;
    }
};