单链表逆序--递归算法

非递归的单链表逆序比较简单，只需要注意三个问题：
1、保存从单链表上拆下的节点；
2、保存当前在链表上的节点，保证不断链；
3、判断循环结束条件。

而基于递归的单链表逆序算法，需要注意两个问题：拆和装
因为本质上递归过程是一个逐层深入、逆序返回的过程，因此，只需要考虑两个条件，即逐层深入时候需要做什么操作和返回过程中需要做什么操作。
（1）拆：将链表拆成两部分，先将当前表头结点从链表中拆出来，接着递归拆余下的链表；

（2）装：当拆到只剩一个结点时，满足递归返回条件，需要将当前链表的尾指针指向上一层拆下来的节点，重新作为一个整体。

得到:
newHead = reverse(head.next);
head.next.next = head;
head.next = null;
递归结束条件：链表只剩一个节点时，直接返回这个节点的指针；

因此，这个算法的核心实在回溯部分，递归的目的是遍历到链表的尾节点，然后通过逐级回溯将节点的next指针反转过来：

class Node{
int data;
Node next;
public Node(int i){
data = i;
}
}

public class ListHandle {
public static void main(String[] args){
Node n1 = new Node(1);
Node n2 = new Node(2);
Node n3 = new Node(3);
Node n4 = new Node(4);
n1.next = n2;
n2.next = n3;
n3.next = n4;
n4.next = null;
listNode(n1);
reverse(n1);
System.out.println("=============");
listNode(n4);
}
//遍历单链表
public static void listNode(Node nhead){
while(nhead.next != null){
System.out.println("当前节点："+ nhead.data);
nhead = nhead.next;
}
System.out.println("当前节点："+ nhead.data);
}
//递归方法
public static Node reverse(Node head){
Node newhead;
if(head == null || head.next == null){
return head;
}

newhead = reverse(head.next);//newhead保存需要被逆序后的链表的头节点
head.next.next = head;//当前递归返回的子链表改变链接方向
head.next = null;//当前递归返回的子链表的尾节点
return newhead;//返回当前递归生成子链表的头结点
}
}