206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

思路1：迭代

以链表的头部节点为基准节点，将基准节点的下一个节点挪到头部作为头节点，当基准节点的next为null，则其已经成为最后一个节点，链表已经反转完成

代码：

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
   let prev = null;
   let curr = head;
   let next = head;
   while (curr !== null){
       next = curr.next;
       curr.next = prev;
       prev = curr;
       curr = next;
   }
   return prev;
};

• 迭代：ES6解构赋值

假设链表为1→2→3→∅，我们想要把它改成 ∅←1←2←3。

在遍历链表时，将当前节点的next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。

时间复杂度：O(n)，其中 nn 是链表的长度。需要遍历链表一次。

空间复杂度：O(1)

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
   let prev = null;
   let curr = head;
   let next = head;
   while (curr !== null){
       [curr.next, curr, prev] = [prev, curr.next, curr];
   }
   return prev;
};

 思路2：递归

时间复杂度：O(n)，其中 n是链表的长度。需要对链表的每个节点进行反转操作

空间复杂度：O(n)，其中 n是链表的长度。空间复杂度主要取决于递归调用的栈空间，最多为 n层

var reverseList = function(head) {
    if (head == null || head.next == null) {
        return head;
    }
    const newHead = reverseList(head.next);
    head.next.next = head;
    head.next = null;
    return newHead;
};