思路1:

1. 通过递归到最后一个节点，然后依次修改原节点的next指针

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null) return null;
        ListNode tmp = head;
        // 反转后的链表头
        ListNode reHead = reverse(head);
        return reHead;
    }

   public ListNode reverse(ListNode node) {
      // 递归终止条件 链表末尾
      if (node.next == null) {
        return node;
      }
      // 递归
      ListNode reverseHead = reverse(node.next);

      ListNode nextNode = node.next;
      // 需要注意原来的链表关系，避免链表回环，这里需要将当前处理的节点的next指针指向空
      node.next = null;
      // 让下一个节点翻转指向当前节点
      nextNode.next = node;
      return reverseHead;
    }
}

思路2

1. 利用栈的特性，节点依次入栈保存节点顺序，然后依次出栈就是倒序顺序
2. 同样需要注意到需要避免链表指针回环的问题

public ListNode reverseList(ListNode head) {
        if (head == null) return null;
        Stack<ListNode> nodeStack = new Stack();
        while(head != null) {
            nodeStack.add(head);
            head = head.next;
        }
        ListNode top = nodeStack.peek();
        while(!nodeStack.empty()) {
            ListNode node1 = nodeStack.pop();
            node1.next = null;
            if(!nodeStack.empty()) {
              // 这里的注意使用peek，不出栈，只获取上一个节点元素
              ListNode node2 =  nodeStack.peek(); 
              // 需要注意原来的链表关系，避免链表回环，这里需要将当前处理的节点的next指针指向空
              node2.next = null;
              node1.next = node2;
            }    
        }
        return top;
    }

Q.E.D.