单链表逆序--递归算法

非递归的单链表逆序比较简单，只需要注意三个问题：
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;//返回当前递归生成子链表的头结点
    }
}