剑指offer面试题16：反转链表

题目：定义一个函数，输入一个链表的头结点，反转该链表并输出反转后的链表的头结点。
解题思路：单向链表只能实现单向遍历，改变链表方向就是要把当前链表的节点指向它的前一个节点，
一旦当前链表指向发生了变化，就不能根据此节点获取到它后面的节点，所以在改变方向前要保存当前节点的下一节点，防止链表断开，
因此需要三个指针来保存当前节点，当前节点的前节点，当前节点的下节点。

注意：如果当前节点没有下一节点，则此节点就是反转后的链表的头结点。

另外一种解决办法是使用一个栈结构，顺序遍历链表，把每个节点依次入栈。待全部节点入栈后，依次把节点从栈中取出并连接，这样得到的链表也是反转后的链表。

 package Solution;

 public class No16ReverseList {

     public static class ListNode {
         int data;
         ListNode next;

         public ListNode() {

         }

         public ListNode(int value, ListNode next) {
             this.data = value;
             this.next = next;
         }
     }

     public static ListNode reverseList(ListNode head) {
         if (head == null)
             throw new RuntimeException("invalid List,can't be null");
         if (head.next == null)
             return head;
         ListNode reversedHead = null;
         ListNode node = head;
         ListNode preNode = null;
         while (node != null) {
             ListNode nextNode = node.next;
             if (nextNode == null)
                 reversedHead = node;
             // 赋值顺序不能变
             node.next = preNode;
             preNode = node;
             node = nextNode;
         }
         return reversedHead;
     }

     public static void print(ListNode head) {
         if (head == null)
             System.out.println("当前链表为空");
         while (head != null) {
             System.out.print(head.data + ",");
             head = head.next;
         }
     }

     public static void main(String[] args) {
         ListNode node1 = new ListNode(4, null);
         ListNode node2 = new ListNode(3, node1);
         ListNode node3 = new ListNode(2, node2);
         ListNode node4 = new ListNode(1, node3);

         print(reverseList(node4));
         System.out.println();
         print(reverseList(new ListNode(5, null)));
         System.out.println();
         print(reverseList(new ListNode()));
         System.out.println();
     }

 }