LeetCode206. 反转链表的两种解法图示（多图！！超详细的解法！！！！）

题目链接：https://leetcode-cn.com/problems/reverse-linked-list/

题意

反转一个单链表。

示例:

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

进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
       
    }
}

一、递归解法

递归解法一开始需要考虑函数的定义，即reverseList需要实现的功能，在这里reverseList需要对给定头节点的链表实现反转，并返回一个节点，既然链表都反转了，返回的必然是反转后的头节点。那么reverseList的功能就是实现反转并返回头节点。
假设链表一开始如下：

则通过调用方法reverseList(head)返回一个newHead之后为：

显然reverseList实现了以head为头节点的链表的反转，但整条链表的反转又是否和子链表的反转有关系？如果传入的形参为head.next，岂不是会完成除了head之外的链表节点的反转？
调用reverseList(head.next）后：

显然，2->3->4->null的子链表完成了反转，此时我只需要将val=2的节点指向头节点，再将头节点指向null即可完成链表的反转。
即：

class Solution {
    public ListNode reverseList(ListNode head) {
        //对子链表进行反转，获取反转后的头节点
        ListNode newHead=reverseList(head.next);
        //将后驱节点连接到head
        head.next.next=head;
        //将反转后的尾节点的后驱设为null
        head.next=null;
        //返回新的头节点
        return newHead;
    }
}

此时不论传入的头节点是什么，reverseList方法都会先完成子链表的反转，然后完成多一个节点的链表反转，那么只要子链表反转正确，整条链表就都反转正确。

那么链表1->2->3->4的反转取决于2->3->4的反转，2->3->4的反转取决于3->4的反转，3->4的反转取决于4的反转，而4不需要反转，新的头节点就是4自身。至此就可以写上递归结束的条件–传入的节点是链表的最后一个节点，即：head.next=null。

class Solution {
    public ListNode reverseList(ListNode head) {
    	if(head.next==null)
    		return head;
        //对子链表进行反转，获取反转后的头节点
        ListNode newHead=reverseList(head.next);
        //将后驱节点连接到head
        head.next.next=head;
        //将反转后的尾节点的后驱设为null
        head.next=null;
        //返回新的头节点
        return newHead;
    }
}

此时解答基本完成，但还需要考虑特殊情况，如果传入的链表本身为空(null)，则调用null.next== null将引发空指针异常，因此还需添加一个判断if(null==head),并返回null。

class Solution {
    public ListNode reverseList(ListNode head) {
        //链表只有一个节点时，无需反转，头节点为自身
        if(head==null||head.next==null)
            return head;
        //对子链表进行反转，获取反转后的头节点
        ListNode newHead=reverseList(head.next);
        //将后驱节点连接到head
        head.next.next=head;
        //将反转后的尾节点的后驱设为null
        head.next=null;
        return newHead;
    }
}

二、迭代解法

迭代法相当于一个新链表的头插，即从head开始不断向新链表进行头插。
如图所示：

进行一次头插：

再头插：

再头插：

最后迭代为：

显然结束条件为head指向null(head==null)。
有了头插的思路，代码也就不再难写：

class Solution {
    public ListNode reverseList(ListNode head) {
    	//防止链表为空
        if(head==null)return null;
        ListNode newHead=null;//建立新链表
        ListNode node;
        while(head!=null){
            node=head.next;//保存head.next
            //插入新链表
            head.next=newHead;
            newHead=head;
            //将head后移
            head=node;
        }
        return newHead;
    }
}