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

题目链接

时间复杂度 O(n)   空间复杂度 O(1)

要求： 给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

思路

本题主要是模拟指针指向的改变，采用虚拟头节点免于头节点的单独处理，因为需要改变指针指向，所以需要把cur.next和cur.next.next.next先临时存储，再执行修改指针的操作。

如图所示：

/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var swapPairs = function(head) {
    let ret = new ListNode(0, head)
    let cur = ret
    while(cur.next !=null && cur.next.next != null){
        let tmp = cur.next 
        let tmp1 = cur.next.next.next
        
        cur.next = cur.next.next //步骤一
        cur.next.next = tmp //步骤二
        cur.next.next.next = tmp1 //步骤三
        
        cur = cur.next.next
    }
    return ret.next
};

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

题目链接

时间复杂度 O(n)   空间复杂度 O(1)

要求：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

思路

本题采用双指针法，由于需要找到倒数第n个节点，快指针先出发，走了n步之后，快慢节点再一起出发，当快节点到达链表末尾时，慢节点刚好是倒数第n个节点，但是我们删除链表的某一节点需要获取其前一个节点，通过cur.next = cur.next.next.next删除节点，所以while的循环条件则需要改为cur.next != null时，才能获取倒数第n个节点的前一个节点。

/**
 * @param {ListNode} head
 * @param {number} n
 * @return {ListNode}
 */
var removeNthFromEnd = function(head, n) {
    let ret = new ListNode(0, head)
    let cur = pre = ret
    while(n--){
        cur = cur.next
    }
    while(cur.next != null){
        cur = cur.next
        pre = pre.next
    }
    pre.next = pre.next.next
    return ret.next
};

面试题 02.07. 链表相交

题目链接

时间复杂度 O(n+m)   空间复杂度 O(1)

要求：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

思路

本题采用双指针法，由于两个链表长度可能不同，首先获取两个链表的长度且计算出两者的长度差len，让较长者先移动len步，然后两者一起向后移动，直到链表A的节点 = 链表B的节点，且并仅仅为val的相等。

注意：交换变量时，如果在同一作用域下，采用[] = []，必须添加分号。

/**
 * @param {ListNode} headA
 * @param {ListNode} headB
 * @return {ListNode}
 */
var getIntersectionNode = function(headA, headB) {
    let lenA =0, lenB = 0
    let curA = headA, curB = headB
    while(curA != null){
        lenA++
        curA = curA.next
    }
    while(curB != null){
        lenB++
        curB = curB.next
    }
    curA = headA, curB = headB
    if(lenA < lenB){
         // 交换变量注意加 “分号” ，两个数组交换变量在同一个作用域下时
        // 如果不加分号，下面两条代码等同于一条代码: [curA, curB] = [lenB, lenA]
        [lenA, lenB] = [lenB, lenA];
        [curA, curB] = [curB, curA];
 
    }
    let len = lenA-lenB
    while(len--){
        curA = curA.next
    }
    while(curA != null){
        if(curA == curB){console.log(111)
            return curA
        }
        curA = curA.next
        curB = curB.next
    }
    return null
    
};

142. 环形链表 II

题目链接    视频链接

时间复杂度 O(n)   空间复杂度 O(1)

要求：给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

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

不允许修改 链表

思路

本题有两大步骤：

• 判断链表是否环
• 如果有环，如何找到这个环的入口

设置fast和slow两个指针，一个速度为2，一个速度为1，那么如果链表有环，必定会在某一时刻相遇，因为fast相对slow移动1，相遇后，另设两个指针，一个从head出发，一个从相遇点出发，当两者相遇时，即为相遇的节点。

/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var detectCycle = function(head) {
    let fast = head, slow = head
    while(fast != null && fast.next != null){
        fast = fast.next.next
        slow = slow.next
        if(slow == fast){
            let index1 = head
            let index2 = fast
            while(index1 != index2){
                index1 = index1.next
                index2 = index2.next
            }
            return index1
        }
    }
    return null

};