算法学习Day4 链表

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

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

重点在于保存要交换的节点的next指向的节点（在交换过程中会重新赋值next，原next值要保存才能保证交换和链表的连接），cur节点指向要交换的那对节点前的那个节点。
在两个需要交换的节点完成交换后要将cur节点指向下一对要交换的节点前的那个节点

var swapPairs = function(head) {
    if(!head || head.next === null) return head

    const dummyNode = new ListNode(0,head)

    let cur = dummyNode
    let temp
    while(cur.next && cur.next.next){
        // 假设节点：虚拟节点 0， 头节点开始：1，2，3，4，5  cur->dummy
        // 记录会被覆盖的两个节点
        // 第一次循环中：head，和head.next.next  即 1，3
        temp = cur.next
        temp1 = cur.next.next.next
        // 第一次将虚拟节点指向原head.next   0->2
        cur.next = cur.next.next
        // 第一次：2->1(head),到这里完成前两个节点的交换
        cur.next.next = temp
        // 将交换后变为第二个节点的next指向原第三个节点 1->3
        temp.next = temp1
        // 将cur前进到要进行交换的两个节点前的那个节点 即cur->1 现在2是head，1是head.next
        cur=cur.next.next
    }
    return dummyNode.next
}

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

19.删除链表的倒数第N个节点
双指针法，重点在于让两个指针相隔n+1个距离，这样当fast走到null的位置时，slow就会指向要删除的倒数第n个节点的前一个节点，从而进行对第n个节点的删除。

var removeNthFromEnd = function(head, n) {
    // 双指针，快慢都先指向虚拟节点
    const dummyNode = new ListNode(0,head)
    let fast = dummyNode, cur = dummyNode
    // 先让快指针走n+1步，
    while(n+1>0){
        fast=fast.next
        n--
    }
    // 然后再让两个指针一起走直到fast=null，这样fast和slow中间的距离才是相隔两个节点，
    // 即当fast为null时，slow指向要删除的节点的前一个节点
    while(fast){
        cur=cur.next
        fast=fast.next
    }
    // 进行删除操作
    cur.next = cur.next.next
    return dummyNode.next
};

面试题 02.07. 链表相交

面试题 02.07. 链表相交
方法一： 连接两个链表的头尾
当一个链表遍历结束后将尾节点指向另一个链表的头节点进行遍历，这样两个指向pA,pB一定会有相交的时候

var getIntersectionNode = function(headA, headB) {
    //方法一
    if (headA === null || headB === null) {
        return null;
    }

    let pA = headA, pB = headB;
    //让一个循环结束后指向另一条链再进行遍历，这样总有相交的时候
    while (pA !== pB) {
        pA = pA === null ? headB : pA.next;
        pB = pB === null ? headA : pB.next;
    }
    return pA;
}

方法一： 暴力？
在curA指向链A的每一个节点时，都遍历一遍链表B。

var getIntersectionNode = function(headA, headB) {
    if (headA === null || headB === null) {
        return null;
    }
    // 从cur指向一条链的头节点
    let curA = headA
    while(curA !== null){
        // 每次循环都要重新定curB为头节点，重新遍历，
        //如果这行定在curA循环外面那么curB在第一次循环后curB=null，
        //下一次循环开始并没改变curB,curB还等于null
        curB = headB
        while(curB !== null){
            if(curA === curB){
                return curA
            }
            curB=curB.next
        }
        curA = curA.next
    }
    return null
}

142.环形链表II

142.环形链表II

还没有完全理解，为何找到两个指针相遇的节点后，从head和这个相遇节点分别出发即可找到入环的节点

// 先判断是否是环形链表
var detectCycle = function(head) {
	//如果不存在头节点或者头的下一个节点就不可能形成环形链表
    if(!head || !head.next) return null;
    //将slow 和 fast分别指向
    let slow =head.next, fast = head.next.next;
    while(fast && fast.next && fast!== slow) {
    	//每次遍历slow向前走一位，fast走两位，当fast=slow时跳出循环，这是记录的fast就是相遇节点
        slow = slow.next;
        fast = fast.next.next; 
    }
    //如果fast和fast.next = null说明没有形成环形链表
    if(!fast || !fast.next ) return null;
    //让两个指针分别从head和相遇节点出发，当两节点相遇时就是入环节点
    slow = head;
    while (fast !== slow) {
        slow = slow.next;
        fast = fast.next;
    }
    return slow;
};

var detectCycle = function(head) {
    if(!head || !head.next) return null;
    let slow =head.next, fast = head.next.next;
    //和上面的方式相似，就是把fast==slow的判断提到while里，在找不到环跳出循环最后return null
    while(fast && fast.next) {
        slow = slow.next;
        fast = fast.next.next;
        if(fast == slow) {
            slow = head;
            while (fast !== slow) {
                slow = slow.next;
                fast = fast.next;
            }
            return slow;
        }
    }
    return null;
};