java 反转jia链表_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; }

* }*/

classSolution

{publicListNode reverseList(ListNode head)

{if(head==null||head.next==null)//链表为空或者只有一个元素

{returnhead;

}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; }

* }*/

classSolution

{publicListNode 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)//和上面一样的原因

{returnhead;

}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;

}

}returnnewNode.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)。