LeetCode 11.29

LeetCode 19 删除链表的倒数第N个结点

//用数组存储，再修改对应索引的节点。（一次循环时间复杂度应该不算高了，居然之打败了6%）
var removeNthFromEnd = function(head, n) {
    if(head.next===null&&n===1){
        return head.next;
    }
    let arr = [];
    let tmp = head;
    while(tmp!==null){
        arr.push(tmp);
        console.log(tmp);
        tmp = tmp.next;
    }
    let len = arr.length;
    if(n===len){
        return arr[1]
    }
    arr[len-n-1].next = arr[len-n].next;
    return head;
};
//快慢指针，需要注意的是n与链表长度相同的边界，此时slow就是倒数第n个结点。
//但是n短于链表长度时，slow不是指向倒数第n个结点的，而是这个结点的前一个结点。
var removeNthFromEnd = function(head, n) {
    if(head.next===null&&n===1) return head.next;
    let fast = head;
    let slow = head;
    while(--n){
        fast = fast.next;
    }
    if(fast.next===null){
        return slow.next;
    }
    fast = fast.next;
    while(fast.next!==null){
        fast = fast.next;
        slow = slow.next;
    }
    slow.next = slow.next.next;
    return head;
};

LeetCode 206 反转链表

//暴力
var reverseList = function(head) {
    let store = [];
    let tmp = head;
    while(tmp!==null){
        store.unshift(tmp.val);
        tmp = tmp.next;
    }
    let res = new ListNode();
    let final = res;
    for(let i of store){
        let node = new ListNode(i);
        console.log(node)
        res.next = node;
        res = node;
    }
    return final.next;
};
//迭代，需要注意的是store不是储存cur，因为后面cur.next已经改变了，这个store是直接储存cur.next的。
//迭代的思想就是从前面开始改变指针的方向，注意head结点会变成最后一个结点，所以前面需要补null。
var reverseList = function(head) {
    let pre = null;
    let cur = head;
    while(cur){
        let store = cur.next;
        cur.next = pre;
        pre = cur;
        cur = store;
    }
    return pre;
};

LeetCode 21 合并两个有序链表

//双指针
var mergeTwoLists = function(list1, list2) {
    let left = list1;
    let right = list2;
    let store = new ListNode();
    let res = store;
    while(left!=null||right!=null){
        let tmp = new ListNode();
        if(left===null){
            tmp.val = right.val;
            right = right.next;
        }
        else if(right===null){
            tmp.val = left.val;
            left = left.next;
        }
        else{
            if(left.val>=right.val){
                tmp.val = right.val;
                right = right.next;
            }
            else{
                tmp.val = left.val;
                left = left.next;
            }
        }
        store.next = tmp;
        store = tmp;
    }
    return res.next;
};
//递归，好像啥也没做，但是跑出来还很快，除了我不李姐，都挺好。
var mergeTwoLists = function(list1, list2) {
    if(list1===null){
        return list2;
    }
    if(list2===null){
        return list1;
    }
    if(list1.val>list2.val){
        list2.next = mergeTwoLists(list1,list2.next);
        return list2;
    }
    else{
        list1.next = mergeTwoLists(list1.next,list2);
        return list1;
    }
};

LeetCode 234 回文链表

//官方的解法都是需要遍历一次的，就不写递归和快慢指针了。
//将结点的值输入数组，判断数组是否为回文。（也可以存到string然后reverse判断是否相等。）
var isPalindrome = function(head) {
    let store = [];
    while(head!==null){
        store.push(head.val);
        head = head.next;
    }
    for(let i = 0;i<store.length/2;i++){
        if(store[i]===store[store.length-i-1]){
            continue;
        }
        return false;
    }
    return true;
};
//进化了
var isPalindrome = function(head) {
    let store = [];
    while(head!==null){
        store.push(head.val);
        head = head.next;
    }
    return store.toString()===store.reverse().toString();
};