LeetCode 链表相关 //重新理解

1. 

剑指 Offer 24

反转链表

927

74.3%

简单

之前用python做过了，但理解的不透彻，重新用JS再做一下。

个人理解：

指针指向→一个值，表示指针里存放的是这个值的地址，即箭头末尾是箭头方向的地址，所以两个指针相等，表示地址相同，即是同一个节点

首先，node.next 相当于链表结构中的左←右→箭头指向(正常就是→)，

其次，如果定义了一个指针如 let cur = head（指向一个链表，相当于头结点），那么再声明一个指针let pre = cur，并不是说pre指向cur，而是指向cur指向的值，也就是说两者都指向head，而不是指针的指针

下面程序中初始的声明采用了解构赋值，中了中间变量存储cur.next的值

注意这里不用cur，直接用head来移动也可以，head本身就是头结点(或者个人理解成指针），但有些时候不能这样用，且为了可读性，声明一个指针比较好

var reverseList = function(head) {
    let [cur,pre] = [head,null];
    while(cur) {
        let temp = cur.next;
        cur.next = pre;
        pre = cur;
        cur = temp;
        // [cur.next,pre,cur] = [pre,cur,cur.next] 
    }
    return pre
};

最后注释掉的那里的解构赋值不易于理解，且得有一定顺序，不建议使用

cur.next = pre这一步就是将→指向←，即断开原链表，成为两个链表

 

2.

排序链表

724

67.9%

中等

指针的val就是所指向结点的val，那么修改cur.val相当于修改了链表这个结点的val

var sortList = function(head) {
    if(!head) return head
    let p = head;
    let arr = []
    while(p) {
        arr.push(p.val);
        p = p.next
    }
    arr.sort((a,b) => a-b);
    // let temp = new ListNode(0);
    p = head
    for(let i = 0; i < arr.length; i++) {
        p.val = arr[i];
        p = p.next
    }
    return head
};

3.

两数相加

4252

39.0%

中等

 这道题思路很简单，就是将传统的加法式子变成 左侧对齐，从左边开始加，向右进位。

但要调试挺久，比如两个链表长度不一致的情况，还有最后一位进位的话，还有再给个val == 1的结点。

我的解法没有修改原链表，而是生成个新链表，并把l1和l2的结点的值给了n1，n2，也方便理解。

合理运用三元表达式很重要。

var addTwoNumbers = function(l1, l2) {
    let node = new ListNode();
    let dummy = node;
    let carry = 0;
    while(l1 || l2) {
        const n1 = l1? l1.val:0
        const n2 = l2? l2.val:0
        const sum = n1 + n2 + carry
        node.next = new ListNode(sum % 10)
        node = node.next
        carry = sum>=10? 1:0
        if(l1) l1 = l1.next
        if(l2) l2 = l2.next
    }
    if(carry == 1) node.next = new ListNode(1)
    return dummy.next
};