逆置单链表

在不带头节点的单链表L，设计一个递归算法，逆置所有节点

package 逆置单链表;
import java.util.*;
//定义一个节点
class Node 
{    
 int data;    
 Node next;     
 public Node(int data) 
 {        
  this.data = data;
  next = null; 
 }
}//完整实现
public class Solution
{    
 public static void main(String args[]) { 
  Scanner sc=new Scanner(System.in);
  int n=sc.nextInt();
  int[] a = new int[n];
        for (int i = 0; i < a.length; i++) {
   a[i]=sc.nextInt();
  }  
  Solution s = new Solution();     
  System.out.print("逆置前链表为:");       
  Node L = s.init(a);    
  s.show(L);        //每次逆置可能改变L，所以就重新建立一次链表        
  System.out.print("逆置方法1：  ");      
  L = s.init(a);       
  s.show(s.reverse1(L));      
  System.out.print("逆置方法2：  ");     
  L = s.init(a);       
  s.show(s.reverse2(L));        //递归最好不要头结点        
  }     //初始化，用尾插法建立链表   
 private Node init(int a[]) {        //增加一个头结点，方便操作       
  Node L = new Node(-1);        
  int n = a.length;       
  if (n == 0)          
   return L;      
  Node rear = L;       
  for (int i = 0; i < n; i++) {    
   Node p = new Node(a[i]);   
   rear.next = p;         
   rear = p;        }      
  return L;    }     //打印一个链表    
 private void show(Node L) {      
  if (L.next == null) return;  
  Node p = L.next;      
  while (p != null) {    
   System.out.print(p.data + " ");    
   p = p.next;        
   }    
  System.out.println();   
  }     //逆置方法1:头插建立新链表   
 private Node reverse1(Node L) {      
  Node t = new Node(-1);       
  Node p = L.next, q;      
  while (p != null) {          
   q = p.next;           
   p.next = t.next;         
   t.next = p;          
   p = q;        
   }       
  return t;    
  }     //逆置方法2：原地逆置 
 private Node reverse2(Node L) {      
  Node p = L.next;        //空链表和一个元素时候        
  if (p == null || p.next == null)            
   return L;        //p,q两个相邻结点的前后关系改变，t保存下一次修改的结点     
  Node q = p.next, t = q.next;     
  while (q != null) {        
   q.next = p;        
   p = q;    
   q = t;    
   if (t != null)     
          t = t.next;          
   }        //注意修改逆置的最后一个结点的后继为空，并且头结点指向原来的最后一个结点        
  L.next.next = null;       
  L.next = p;       
  return L;     
  }     //递归逆置，注意这里用的是L.next  
}