前端算法系列-链表02

24. 两两交换链表中的节点

这道题不是很难，在纸上画图找到思路很容易就能写出来，对于要用到的节点可以提前声明变量保存起来，这样可以使程序中的逻辑更清晰，不容易出错

var swapPairs = function (head) { 
    let myhead = new ListNode(-1,head)
    let p = myhead
    while(p.next && p.next.next){
        let first = p.next
        let second = first.next
        let third = second.next
        p.next = second
        second.next = first
        first.next = third
        p = first
    }
    return myhead.next
}

19.删除链表的倒数第N个节点

如果想要降低时间复杂度，一次遍历就完成，自然而然的会想到使用双指针来解决

var removeNthFromEnd = function (head, n) { 
    let myhead = new ListNode(1,head)
    let fast = myhead
    let slow = myhead
    // 本来快指针要先走n步，为了删除方便，要走到删除指针的前一个节点，所以要先走n+1步
    for(let i = 0;fast;i++){
        if(i < n+1){
            fast = fast.next
            continue;
        }
        fast = fast.next
        slow = slow.next

    }
    slow.next = slow.next.next
    return myhead.next
}

面试题 02.07. 链表相交

var getIntersectionNode = function(headA, headB) {
    let countA = 0
    let countB = 0
    let p = headA
    while(p){
        countA++
        p = p.next
    }
    p = headB
    while(p){
        countB++
        p = p.next
    }

    let pa = headA
    let pb = headB

    for(let i=0;i<Math.abs(countA - countB);i++){
        if(countA > countB){
            pa = pa.next
        }else{
            pb = pb.next
        }
    }

    let flag = null
    while(pa && pb){
        if(pa === pb){
            flag = pa

            break
        }
        pa = pa.next
        pb = pb.next
    }
    return flag
};

142. 环形链表 II

const judge = function(point,arr){
    let flag = false
    for(let i=0;i<arr.length;i++){
        if(point === arr[i]){
            flag = true
            break
        }
    }
    return flag
}

var detectCycle = function(head) {
    let p = head
    let list = []
    let flag = null
    while(p){
        if(judge(p,list)){
            flag = p
            break
        }
        list.push(p)
        p = p.next
    }
    return flag
};