题目1： 24. 两两交换链表中的节点

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

示例 1：

输入：head = [1,2,3,4]

输出：[2,1,4,3]

思路

先想了边界条件，没有节点或者只有一个节点，则不需要交换，直接返回节点；然后想的两个指针p，q进行交换，但是发现还需要p的前一个节点更新为q，一次交换后，p再指向p的下一个节点，q再指向p的下一个节点，所以写着写着第一版，写出了4个变量，😓，写法是有点丑陋，还不好理解，这脑袋瓜子就是想不太清楚。

// 第一版本
var swapPairs = function(head) {
    if (!head || !head.next) {
        return head;
    }
    let dummy = new ListNode()
    let pre = dummy;
    let p = head;
    let q = p.next;
    let next = q.next;
    while (p && q) {
        q.next = p;
        p.next = next;
        pre.next = q;
        if (!next || !next.next) {
            break;
        }
        pre = p;
        p = next;
        q = next.next;
        next = q.next;
    }
    return dummy.next;
};

// 看了题解后，发现只需要记录前一个节点，在循环里拿到要交换的两个节点进行交换，这样可以节省2个变量，是清晰了些，按照题解优化后如下：

// 代码清爽了些
var swapPairs = function(head) {
    if (!head || !head.next) {
        return head;
    }
    let dummy = new ListNode()
    dummy.next = head;
    let pre = dummy;
    while (pre.next && pre.next.next) {
        let p = pre.next;
        let q = pre.next.next;

        p.next = q.next;
        q.next = p;
        pre.next = q;

        pre = p;
    }
    return dummy.next;
};

然后题解中还有一个递归解法，我是没想出来的，看了一会明白了思路：

终止条件和上面一样
每层循环，交换2个节点，head以及head.next, head.next成为新的头节点newHead，递归交换从第三个点开始的后面的链表即newHead.next开始的链表，返回交换后的头节点，赋值给head的next，newHead.next = head
返回新的头节点newHead

var swapPairs = function(head) {
    if (!head || !head.next) {
        return head;
    }
    const newHead = head.next;
    head.next = swapPairs(newHead.next);
    newHead.next = head;
    return newHead;
};

这一道题花了挺长时间，是不好写，链表的题还不够熟悉。

题目2: 19. 删除链表的倒数第 N 个结点

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

示例 1：

输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5]

思路

这个题之前做过，现在做起来比较快，思路就是快慢指针，fast指针先走n步，然后slow再出发，这里注意的就是fast从head开始出发，slow借助哑节点，因为删除指针的话，是需要知道删除节点的上一个节点的，所以slow需要走到前一个节点，借助哑节点，一个是删除不用考虑头节点的特殊情况，一个是从dummy走n步，是走到了要删除节点的前一个节点，删除也方便。代码如下

var removeNthFromEnd = function(head, n) {
    let p = head;
    while(n-- > 0 && p) {
        p = p.next
    }
    const dummy = new ListNode();
    dummy.next = head;
    let q = dummy;
    while (p) {
        p = p.next;
        q = q.next;
    }
    q.next = q.next.next;
    return dummy.next;
};

题目3 面试题 02.07. 链表相交

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

图示两个链表在节点 c1 开始相交：

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须保持其原始结构。

思路

这个题，一开始想的逆转链表，从后往前遍历，但是发现一提交错误，看了一下题，不能修改链表结构，遂卒😓，

然后就按照长度diff来计算吧，计算出来diff，长度长的先走diff步，然后两个列表一起往后走，如果遇到相同节点，就是相交节点，如果没有遇到，则不相交。

var getIntersectionNode = function(headA, headB) {
   let lenA = 0
   let lenB = 0;
   let nodeA = headA;
   let nodeB = headB;
   while (nodeA) {
       nodeA = nodeA.next;
       lenA++;
   }
   while (nodeB) {
       nodeB = nodeB.next;
       lenB++;
   }
   let longList;
   let shortList;
   let diff = 0;
   if (lenA > lenB) {
       longList = headA;
       shortList = headB;
       diff = lenA - lenB;
   } else {
       longList = headB;
       shortList = headA;
       diff = lenB - lenA;
   }
   // 长链表先走diff步
   while(diff-- > 0) {
       longList = longList.next;
   }
   while(longList && shortList) {
       if (longList === shortList) {
           return longList;
       }
       longList = longList.next;
       shortList = shortList.next;
   }
   return null;
};

题目4: 142. 环形链表 II

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

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

不允许修改链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1 输出：返回索引为 1 的链表节点解释：链表中有一个环，其尾部连接到第二个节点。

思路

虐了，看了半天，觉得还需要消化消化，是否有环这个就是快慢指针来判断，快指针走两步，慢指针走一步，像在操场跑步一样，跑的快的肯定会追上跑的慢的，而且快指针相对于慢指针每次就追击一个点，所以肯定会在某个点相遇，而不会一直错过慢指针。

对于找入口点，看了半天推到，最后看carl的视频才有点感觉，推荐啊，这个讲的还是很详细的。目前觉得还需要消化消化，核心是从头开始和从相遇点开始一样的速度走，它俩相遇的点就是入口点，而这个推导就是数学推导。

假设环外距离是a，环内慢指针走了b步后，两个指针相遇，假设环内剩余距离是c，相遇时，肯定有的一个关系是快指针走的步数是慢指针的2倍, 快指针在环里比慢指针至少多走了1圈，假设多走了n圈。

2(a + b) = a + b + n(b + c)
a = n(b + c) - b
a = (n-1)(b+c) +c

如果上面的理解了，最后代码写起来就比较简单：

var detectCycle = function(head) {
    if (!head || !head.next) {
        return null;
    }
    let fast = head.next.next;
    let slow = head.next;
    while (fast && fast.next) {
        if (fast === slow) {
            let index1 = fast;
            let index2 = head;
            while (index1 !== index2) {
                index1 = index1.next;
                index2 = index2.next;
            }
            return index1;
        }
        fast = fast.next.next
        slow = slow.next;
    }
    return null;
};

总结

这几天的学习，链表部分应该又多掌握了一些，继续加油，继续进步吧。

题目代码github地址

8.28又写了一遍，发现第一遍写的好像还好一些，链表的题感觉容易出错，操作指针容易操作迷，一些边界的处理，以及虚拟头结点的应用。

什么时候需要用虚拟头节点？

涉及到插入、删除操作时，例如203移除元素，19删除链表倒数第n个元素，24交换链表的节点（涉及指针的操作）
其他没有用到虚拟头节点的：206反转链表、链表相交（无删除），环形链表（无删除）

链表.png

【前端er每日算法】Leetcode链表4题-24两两交换节点19删除链表倒数第n个节点/链表相交/142环形链表二

题目1： 24. 两两交换链表中的节点

思路

题目2: 19. 删除链表的倒数第 N 个结点

思路

题目3 面试题 02.07. 链表相交

思路

题目4: 142. 环形链表 II

思路

总结