206.反转链表

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-linked-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

思考

本来想的是遍历，然后按头插法生成一个新链表，但这样花费一倍的空间，不可取。链表玩的就是指针！

实现反转，本质不就是把curr的next指向前一个元素pre。但接下来，curr要移到curr.next，因为已经断开了，所以要提前保存下。

在这之前，pre也要移动到当前curr的位置。

所以关键的四步：

next = curr.next
curr.next = pre
pre = curr
curr = next

最后pre指向的就是末尾元素，循环终止条件curr = null 

解法2 递归

反转链表可以看成把 head拼人反转好的子链表，所以就可以是一个递归问题。递归的出口是链表为空或者只有一个节点，直接返回。

此时上一层的head指向的是反转后子链表的最后一个节点比如1->2->3 。 1->2<-3。下面要把head并进来。

head.next.next = head
head.next = null

再返回改好的链表头节点3。可以发现，当递归到达最底层，返回头结点3.后面每个递归返回的都是这个。只是不断把头结点并入，这就是归的过程。

视频讲解。

https://leetcode-cn.com/problems/reverse-linked-list/solution/shi-pin-jiang-jie-die-dai-he-di-gui-hen-hswxy/ 

---

代码实现

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
    let pre = null
    let curr = head
    let next = head

    while (curr !== null) {
        
        // next = curr.next
        // curr.next = pre
        // pre = curr
        // curr = next

        //以上四句话，在es6中，解构赋值
        [curr.next, pre, curr] = [pre, curr, curr.next]

    }

    return pre
    
};

递归代码

  /**
     * Definition for singly-linked list.
     * function ListNode(val) {
     *     this.val = val;
     *     this.next = null;
     * }
     */
    /**
     * @param {ListNode} head
     * @return {ListNode}
     */
    var reverseList = function(head) {
        //递归出口，只有1个节点或没有节点，不需要反转
        if (head == null || head.next == null) {
            return head;
        }
        //返回反转的子链表
        const p = reverseList(head.next)
        //此时的head应该是指向子链表的最后一个位置，需要把head加入进来
        head.next.next = head
        head.next = null 
        
        //返回反转链表的头结点
        return p
    };

 

---

知识

在es6中，交换两个变量的值，可以用解构赋值，不用中间变量。比如

a=1
b=2
[a,b] = [b,a]

注意的是，顺序其实不重要a,变成了当前的b，b变成了当前的a

[curr.next, pre, curr] = [pre, curr, curr.next]

curr.next变成了现在的pre

pre变成了现在的curr

curr变成了现在的curr.next

就像有个未知的空间，保存了所有现在的状态

---

复习

2021.6.12