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 时退出，此时前一个节点的指针正好指向链表的最后一个节点，返回 即可。