链表的 反转Java 代码

1. 链表的 反转Java 代码
   
2. 
   
3. public class ReverseSingleList  
4. {  
5.     /** 
6.      * 递归，在反转当前节点之前先反转后续节点 
7.      *  
8.      * @param head 
9.      * @return 
10.      */  
11.     public static Node reverse(Node head)  
12.     {  
13.         if (null == head || null == head.getNextNode())  
14.         {  
15.             return head;  
16.         }  
17.         //  
18.         Node reversedHead = reverse(head.getNextNode());  
19.         //  
20.         head.getNextNode().setNextNode(head);  
21.         //  
22.         head.setNextNode(null);  
23.         return reversedHead;  
24.     }  
25.   
26.     /** 
27.      * 遍历，将当前节点的下一个节点缓存后更改当前节点指针 
28.      *  
29.      * @param head 
30.      * @param mode 
31.      *            仅用作区分于同名方法 
32.      * @return 
33.      */  
34.     public static Node reverse(Node head, int mode)  
35.     {  
36.         if (null == head)  
37.         {  
38.             return head;  
39.         }  
40.         Node pre = head;  
41.         Node cur = head.getNextNode();  
42.         Node next;  
43.         while (null != cur)  
44.         {  
45.             next = cur.getNextNode();  
46.             cur.setNextNode(pre);  
47.             pre = cur;  
48.             cur = next;  
49.         }  
50.   
51.         // 将原链表的头节点的下一个节点置为null，再将反转后的头节点赋给head  
52.         head.setNextNode(null);  
53.         head = pre;  
54.   
55.         return head;  
56.     }  
57.   
58.     public static void main(String[] args)  
59.     {  
60.         Node head = new Node(0);  
61.         Node tmp = null;  
62.         Node cur = null;  
63.         // 构造一个长度为100的链表，保存头节点对象head  
64.         for (int i = 1; i < 100; i++)  
65.         {  
66.             tmp = new Node(i);  
67.             if (1 == i)  
68.             {  
69.                 head.setNextNode(tmp);  
70.             } else  
71.             {  
72.                 cur.setNextNode(tmp);  
73.             }  
74.             cur = tmp;  
75.         }  
76.   
77.         // for (int i = 0; i < 100; i++)  
78.         // {  
79.         // tmp = new Node(i);  
80.         // if (0 != i)  
81.         // {  
82.         // cur.setNextNode(tmp);  
83.         // }  
84.         // cur = tmp;  
85.         // }  
86.         head = reverse(head, 0);  
87.         //  
88.         while (null != head)  
89.         {  
90.             System.out.print(head.getPosition() + "\n");  
91.             head = head.getNextNode();  
92.         }  
93.     }  
94. }