反转一个单链表。

Input: 1->2->3->4->5->NULL
Output: 5->4->3->2->1->NULL

• 时间复杂度：O(n)，假设 n 是列表的长度，那么时间复杂度为 O(n)。
• 空间复杂度：O(1)。

在遍历列表时，将当前节点的 next 指针改为指向前一个元素。由于节点没有引用其上一个节点，因此必须事先存储其前一个元素。在更改引用之前，还需要另一个指针来存储下一个节点。不要忘记在最后返回新的头引用！

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null||head.next==null) return head;
        ListNode pre= null;
        ListNode cur = head;
        ListNode nextNode = cur.next;
        while(nextNode!=null){
            cur.next = pre;
            pre = cur;
            cur=nextNode;
            nextNode = cur.next;
        }
        cur.next = pre;
        return cur;
    }
}

反转步骤：

从头到尾遍历原链表，每遍历一个结点
将其摘下放在新链表的最前端。
注意链表为空和只有一个结点的情况。

class Solution {
    public ListNode reverseList(ListNode head) {
        // 构建哑节点
        ListNode dummy = new ListNode(0);
        ListNode node = head;
        ListNode temp = null;

        while (node != null) {
            // 保存下一个节点
            temp = node.next;
            // 插入节点头部
            node.next = dummy.next;
            dummy.next = node;
            // node指针后移
            node = temp;
        }

        return dummy.next;
    }
}