leetcode 206.反转链表

本题来源于leetcode,点我传送

1. 题目描述

1.1 具体示例

1.2 提示与进阶

1.3 提示接口函数

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* reverseList(struct ListNode* head){

}

2. 思路一：三指针翻转

2.1 思路分析

思路：当我们遍历链表时把当前节点的指针改为指向前一个节点，所以由于前一个节点没有事先保存，所以我们要先储存前一个节点，在改引用之前，也要先存储后一个节点，不然遍历到下一个的时候就找不到下一个节点了

假如示例为下：

我们分别给两个指针，一个指定NULL，另外两个分别指定前两个节点

然后分别往前走，更改指针指向

什么时候结束？

是n1把最后一个节点的指针反转，即n2为空的时候使得整个链表能够反转

2.2 具体步骤

1.新建一个prev指针置为NULL，cur指向head，新建一个next,这就是三个指针

2.在循环体中，next保存cur下一个结点数据，同时cur指向前一个结点prev，然后prev移动到当前cur位置，cur移动到当前next位置，以此用while循环，需要注意指向顺序

2.3 代码实现

第一次代码尝试：

struct ListNode* reverseList(struct ListNode* head){
//先要判断，假如都是空，或者只有一个head，没有其他节点直接返回头
if(head==NULL||head->next==NULL )
{
    return head;
}
//初始化三个指针
struct ListNode *prev=NULL;
struct ListNode *cur=head;
struct ListNode *next=head->next;
while(cur)
{
   //翻转
   	 cur->next=prev;//cur指向prev   
   //往后迭代
   	 prev=cur;//prev往后走一个
     cur=next;//cur往后走  
     next= next->next;
}
	return prev;
}

分析错误原因：

当走到最后之前的时候，都没问题

但当我走到在最后的时候，我们的next节点已经空了

所以加一个判断于迭代中，但是不可以把next为NULL作为循环判断条件，因为会有一个节点没反转

   //往后迭代
   prev=cur;//prev往后走一个
     cur=next;//cur往后走  
     if(next)
     {
     next= next->next;
     }

就通过了

最终代码：

struct ListNode* reverseList(struct ListNode* head){
//先要判断，假如都是空，或者只有一个head，没有其他节点直接返回头
if(head==NULL||head->next==NULL )
{
    return head;
}
//初始化三个指针
struct ListNode *prev=NULL;
struct ListNode *cur=head;
struct ListNode *next=head->next;
while(cur)
{
   //翻转
   cur->next=prev;//cur指向prev   
   //往后迭代
   prev=cur;//prev往后走一个
   cur=next;//cur往后走  
     if(next)
     {
     next= next->next;
     }
}
return prev;
}

3. 思路二：头插（不创造新节点）

3.1 思路分析

相当于创一个新的链表，然后分别头插到新链表,全部插完后，可以使得新的链表变成原来链表的反向

3.2 具体步骤

取原链表中的节点头插到新节点

1. 新建一个next用来保存下一个节点

2. 取下cur头插，则cur变成新的头

3.不断走，循环直到取完，都头插到新链表里面

3.3 代码实现

这个方法写起来是比较简单的

struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* cur=head;
    struct ListNode*newHead=NULL;
    while(cur)
    {
        struct ListNode* next=cur->next;//声明next
        cur->next=newHead;//头插
        newHead=cur;//*把cur变成newHead
        cur=next;//cur回到原来的链表的next
        //构成循环直到指空
    }
    return newHead;
}

4.思路三 递归法：

4.1 思路分析

这个方法解决的是原来提示进阶里的使用递归的方法

这个递归方法理解起来不是很简单,需要配合代码和动画一起看方便理解,我也是看答案自学才写出来

如有兴趣请点我转到官方题解，看动画演示

递归版本稍微复杂一些，其关键在于反向工作。假设链表的其余部分已经被反转，现在应该如何反转它前面的部分？

需要注意的是 n1的下一个节点必须指向∅。如果忽略了这一点，链表中可能会产生环。

4.2 代码实现

本题解法的说明借用了NoColor96大佬的解释

struct ListNode* reverseList(struct ListNode* head) {
    /**
     * 以链表1->2->3->4->5举例
     */
     if (head == NULL || head->next == NULL) {
        return head;
    }
            /*
                直到当前节点的下一个节点为空时返回当前节点
                由于5没有下一个节点了，所以此处返回节点5
             */

        //递归传入下一个节点，目的是为了到达最后一个节点
   struct ListNode* newHead = reverseList(head->next);
                /*
            第一轮，head为5，head->next为空，返回5
            第二轮，head为4，head->next为5，执行head->next->next=head也就是5->next=4，
                      把当前节点的子节点的子节点指向当前节点
                      此时链表为1->2->3->4<->5，由于4与5互相指向，所以此处要断开4->next=null
                      此时链表为1->2->3->4<-5
                      返回节点5
            第三轮,head为3，head->next为4，执行head->next->next=head也就是4->next=3，
                      此时链表为1->2->3<->4<-5，由于3与4互相指向，所以此处要断开3->next=null
                      此时链表为1->2->3<-4<-5
                      返回节点5
            第四轮，head为2，head->next为3，执行head->next->next=head也就是3->next=2，
                      此时链表为1->2<->3<-4<-5，由于2与3互相指向，所以此处要断开2.next=null
                      此时链表为1->2<-3<-4<-5
                      返回节点5
            第五轮，head为1，head->next为2，执行head->next->next=head也就是2->next=1，
                      此时链表为1<->2<-3<-4<-5，由于1与2互相指向，所以此处要断开1->next=null
                      此时链表为1<-2<-3<-4<-5
                      返回节点5
            完成，最终头节点5->4->3-2->1
         */
         head->next->next = head;
          head->next = NULL;
        return newHead;
    }

总结：

这道题是很经典的链表题，常常出现，需要仔细思考掌握这道题背后的方法