LeetCode 206——链表反转（JAVA）

题目：

反转一个单链表。

示例:

输入: 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(int x) { val = x; }
 * }
 */
class Solution
{
    public ListNode reverseList(ListNode head)
    {
        if(head==null||head.next==null)//链表为空或者只有一个元素
        {
            return head;
        }
        else
        {
            ListNode newHead=reverseList(head.next);//递归进行，通过这个语句之后，head节点之后的节点已经全部翻转完毕，这个时候，只需要把head节点放在新链表最后就好
            head.next.next=head;//head节点应该放在head.next.next
            head.next=null;//head已经是最后一个节点，所以head.next=null
            return newHead;//返回新的头节点，作为递归的起点
        }
    }
}

以上为递归翻转链表的代码

递归终止条件：1、head为空。2、head.next为空

递归过程：我们令新的头节点为newHead，新的头节点newHead应该是head 翻转完之后的head.next。同时head也应该放在了head.next的后面，并令head.next=null。这样我们就把head放在了新链表的最后面（递归到最后面才实现把、这一步，下面我们画一个图表示一下这个递归的过程）。

算法分析：

时间复杂度，空间复杂度分析：涉及到递归，每递归一次的时间复杂度为O(1)，因此整个递归时间复杂度为O(n)，n为链表长度。对于空间复杂度，递归算法不涉及新空间的开辟，因此空间复杂度也是O(n)，（这里对于空间复杂度的分析好像有问题......）

那么有没有非递归算法哪？有的！实际上，大多数的递归算法都是可以非递归实现的，只是稍微复杂了一点。

那么先上非递归算法代码，再分析这个算法吧！

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution
{
    public ListNode reverseList(ListNode head)
    {
        ListNode newNode=new ListNode(-1);
        ListNode node1,node2,node3;
        newNode.next=head;
        node1=newNode;
        if(node1.next==null||node1.next.next==null)//和上面一样的原因
        {
            return head;
        }
        else
        {
            node2=node1.next;
            node3=node2.next;
            while(node3!=null)//以下代码是关键，实现了，每次将一个节点调到头节点位置，然后node2,node3指针后移。
            {
                node2.next=node3.next;
                ListNode temp=node1.next;
                node1.next=node3;
                node3.next=temp;
                node3=node2.next;
            }
        }
        return newNode.next;
    }
}

算法分析:

1、设置了一个虚拟的头节点newNode,以及三个指针，node1、node2、node3。

2、令newNode.next指向head.

3、如果newNode.next.next或者newNode.next==null直接返回原链表

4、否则，令node2指向node1.next，node3指向node2.next

5、如果node3不为空，执行一下部分：

node3指向的是待处理节点，node2指向待处理节点前一节点。

令node2.next指向node3.next

设立临时节点temp，存储node1.next

令node1.next指向node3,即将待处理节点放在头节点的位置，而令node3.next为temp

更新node3的值为node2.next

返回翻转之后的结果newNode.next

下面是手画的代码运行过程：将a b c  翻转为c b a

算法的分析：时间复杂度O(n),n为链表长度，空间复杂度，每循环一次，要开辟一个临时的节点空间，最后保留的只有一个，因此空间复杂度O(1)。