Java 反转单向链表

<pre name="code" class="java">package com.boge.first;
public class Test {
public static void main(String[] args) {
Node n0 = new Node(0);
Node n1 = new Node(1);
n0.next = n1;
Node n2 = new Node(2);
n1.next = n2;
Node n3 = new Node(3);
n2.next = n3;
Node n4 = new Node(4);
n3.next = n4;
Node n5 = new Node(5);
n4.next = n5;
Node res = reverse(n0);
while(res!=null&&res.next!=null){
System.out.print(res.value+" ");
res = res.next;
}
if(res!=null){
System.out.println(res.value);
}
}

public static Node reverse(Node node) {
if(node==null||node.next == null){
return node;
}else{
Node nextNode = node.next;
node.next = null;
Node res = reverse(nextNode);
nextNode.next = node;
return res;
}
}
private static class Node{
int value;
Node next;
public Node(int value){
this.value = value;
}
}
}

上面是全部代码，包括测试代码，其中，reverse(Node node)是关键代码（递归实现）

（1）下面是反转单向链表的递归实现：

<pre name="code" class="java">public static Node reverse(Node node) {
if(node==null||node.next == null){
return node;
}else{
Node nextNode = node.next;
node.next = null;
Node res = reverse(nextNode);
nextNode.next = node;
return res;
}
}

在每次递归栈中，存放currentNode（即node，为避免前两个节点的相互引用，将node.next先指向null）,nextNode,以及反转返回链表（不包含当前节点node）。返回时将当前节点加上（即nextNode.next = node）。

（2）下面是反转单向链表的非递归实现：

public static Node reverse(Node node) {
Node preNode = null;
Node nextNode = null;
while(node != null){
nextNode = node.next;
node.next = preNode;
preNode = node;
node = nextNode;
}
return preNode;
}

原理很简单，有三个节点：前一个节点，当前节点，后一个节点。每次首先记录当前节点的下一个节点，方便后面使用，然后把当前节点反转指向上一个节点，然后将前一个节点指针指向当前节点，再将当前节点的指针指向下一个节点。最后，当当前节点为null 时退出，此时前一个节点的指针正好指向链表的最后一个节点，返回 即可。