代码随想录算法训练营第四天｜ 24. 两两交换链表中的节点 、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交 、142.环形链表II

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

24. 两两交换链表中的节点
题目描述：给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
解题思路：首先两两交换需要在cur节点后有cur.next 和 cur.next.next再进行交换，只有cur.next就不用交换。

• cur.next -> cur.next.next
• cur.next.next = temp1
• cur.next.next.next = temp2
• 向后移动cur

/**
* Definition for singly-linked list.
* function ListNode(val, next) {
*     this.val = (val===undefined ? 0 : val)
*     this.next = (next===undefined ? null : next)
* }
*/
/**
* @param {ListNode} head
* @return {ListNode}
*/
var swapPairs = function(head) {
   let dummy = new ListNode(-1,head)

   let cur = dummy
   // 当后面存在两个listnode时候才进行交换
   
   while(cur.next!=null && cur.next.next!=null){
       let temp1 = cur.next
       let temp2 = cur.next.next.next
       cur.next = cur.next.next
       cur.next.next = temp1
       cur.next.next.next = temp2
       cur = cur.next.next
   }
   return dummy.next
};

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

9.删除链表的倒数第N个节点
题目描述：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
解题思路：删除链表节点需要找到需要删除节点的前一个节点，cur.next = cur.next.next。使用快慢指针，fast指针比slow指针快n步，当fast.next == null时，slow指向的节点为倒数第N个节点的前一个节点。

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} n
 * @return {ListNode}
 */
var removeNthFromEnd = function(head, n) {
    let dummy = new ListNode(-1,head)
    let slow = dummy
    let fast = dummy
    for(let i = 0;i<n;i++){
        fast = fast.next
    }
    while(fast.next!=null){

        slow = slow.next
        fast = fast.next
    }
    slow.next = slow.next.next
    return dummy.next

};

面试题 02.07. 链表相交

面试题 02.07. 链表相交
题目描述：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
解题思路：求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置。向后移动看curA是否等于curB

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} headA
 * @param {ListNode} headB
 * @return {ListNode}
 */
var getIntersectionNode = function(headA, headB) {
    let lengthA = 0
    let lengthB = 0
    let originalHeadA = headA
    let originalHeadB = headB
    while(originalHeadA){
        originalHeadA = originalHeadA.next
        lengthA++
    }
    while(originalHeadB){
        originalHeadB = originalHeadB.next
        lengthB++
    }
    console.log(lengthA,lengthB)
    let curA = headA
    let curB = headB
    let gap = Math.abs(lengthA-lengthB)
    if(lengthA>lengthB){
        for(let i=0;i<gap;i++){
            curA=curA.next
        }
    }else{
       for (let i = 0; i < gap; i++) {
            curB = curB.next
        }
    }
    // Find the intersection node
    while (curA !== curB) {
        curA = curA.next;
        curB = curB.next;
    }
    return curA;
    
};

142.环形链表II

142.环形链表II
题目描述：给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

解题思路：快慢指针。slow指针步长1，fast指针步长2。若存在环，fast指针先进入环内，当slow指针走到环的入口时，fast指针与slow指针的距离为N。由于fast指针每次走2步，slow指针走1步，两者的距离逐渐缩小，N N-1 N-2 …2 1 0 直到fast指针与slow指针相遇。此时相遇的接地为meet。
假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。

那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。

因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,

再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

这个公式说明什么呢？

先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z，

这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var detectCycle = function(head) {
    let slow = head
    let fast = head
    while(fast && fast.next) {
        slow = slow.next
        fast = fast.next.next
        // 相遇节点
        if(slow==fast){
            
            let meet = slow
            while(meet!=head){
                meet = meet.next
                head = head.next
            }
            return head
        }
    }
    return null

    
};