时间是伟大的作者，她能写出未来的结局。                               ——卓别林

目录

题目描述：

方法1：迭代法（翻指针）

方法2：头插法 

方法3：递归法 

题目描述：

给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：
输入：head = []
输出：[]

方法1：迭代法（翻指针）

迭代法也称辗转法，是一种不断用变量的旧值递推新值的过程，跟迭代法相对应的是直接法(或者称为一次解法)，即一次性解决问题。和循环其实和像，都有结束的条件。
这里就要用到我们之前学习的双指针的方法。假如要反转的数字是 1 2 3。

 

但是这样写又存在很大的问题，在第二次反转指针的时候，n2和n2的下一个结点失去了连续，下次就找不到n2的下一个结点了，所以我们还要设置一个变量来保存n2的下一个结点。

改进： 

有了上面的思路，我们就可以写代码了。

struct ListNode* reverseList(struct ListNode* head)
{
   if(head==NULL)
     return NULL;
    struct ListNode*n1=NULL,*n2=head,*n3=head->next;
    while(n2)
    {
        n2->next=n1;//这里就是反转指针
        n1=n2;
        n2=n3;
        if(n3)//当n3为空的时候，就不能使用n3->next，所以这里一定要判断
        n3=n3->next;
    }
      return n1;//结束n1为头指针，返回头指针
}

时间复杂度O(N)。空间复杂度O(1)。

方法2：头插法 

头插法也就是我们学习单链表那样，在链表的头结点上面插入数据。这里我们就要先设置一个NULL的头结点，再把原链表的结点一个一个取下来，再链接到NULL的头上面，再把头结点改为新链接上去的结点。

这题同样会使用到双指针。可见双指针问题还是非常实用的，一定要学会。 

struct ListNode* reverseList(struct ListNode* head)
{
   struct ListNode*cur=head;
   struct ListNode*next=NULL;
   struct ListNode*newhead=NULL;
       while(cur)
       {
           next=cur->next;
           cur->next=newhead;//头插
           newhead=cur;//头结点被重新赋值
           cur=next;
       }
       return newhead;
}

时间复杂度O(N)。空间复杂度O(1)。

方法3：递归法 

递归简单来说就是在运行过程中不断调用自己，直到碰到终止条件，返回结果的过程。

对于递归法可能不太好理解，我自己也看了很久，不知道讲的对不对。如果讲错了，还望各位老铁能够指证。对于递归法，我们先把代码放处理啊，再通过一步一步的画图，好好地理解递归的奥妙。 

struct ListNode* reverseList(struct ListNode* head)
{
     if(head==NULL||head->next==NULL)
     return head;
     struct ListNode*newhead=reverseList(head->next);
     head->next->next=head;
     head->next=NULL;
     return newhead;
}

 对于这个代码还是比较好理解的，当链表为空时，直接返回head，也就是NULL。当链表的下一个结点为空的时候，也就是链表只有一个结点，所以我们也是返回head。

if(head==NULL||head->next==NULL)
     return head;

假设要反转的数字是 1  2  3  4  5。

 

第一次递归：即执行下面的语句。
 

虽然说递归的代码简洁，但是不怎么好理解，空间复杂度也为O(N)。 所以还是建议使用双指针的做法，这个方法一定要知道。