双指针链表题目
目前对我来说双指针分为 快慢指针、左右指针(从两端到中心、从中心到两端)
因为刷题较少，没有办法覆盖到所有类型，不足的地方还恳请各位前辈指出。
题1 剑指 Offer 22. 链表中倒数第k个节点
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。
例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。
快慢指针印象最深刻的是 快慢指针的相对距离的运用。 在只允许遍历一次链表的前提下，相对距离就显得聪明一点点hhh。
解题思路：
/**
* Definition for singly-linked list.
* function ListNode(val) {
* this.val = val;
* this.next = null;
* }
*/
/**
* @param {ListNode} head
* @param {number} k
* @return {ListNode}
*/
var getKthFromEnd = function(head, k) {
let fast = head,slow = head;//定义两个指针
let n = 0;//作为计数使用，当慢指针和快指针的相对距离为k时，慢指针开始前移
while(fast.next){//当指针指向的下一个不为空
fast = fast.next;
n++;
// 当快指针和慢指针之间的相对距离为k的时候，
//快指针 走到链尾，慢指针就位于倒数第k个节点
if(n>=k){//慢指针开始前移
slow = slow.next;
}
}
//返回慢指针
return slow;
};
题2 剑指 Offer 25. 合并两个排序的链表
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。
示例1：
输入：
1->2->4,
1->3->4
输出：
1->1->2->3->4->4
/**
* Definition for singly-linked list.
* function ListNode(val) {
* this.val = val;
* this.next = null;
* }
*/
/**
* @param {ListNode} l1
* @param {ListNode} l2
* @return {ListNode}
*/
var mergeTwoLists = function(l1, l2) {
//创建虚拟 头节点
const res = new ListNode(0);
// p 指向虚拟头节点
let p = res;
//用 p1 指向 l1 ,p2 指向 l2
let [p1,p2] = [l1,l2];
//当p1 和p2 同时不为空
while(p1&&p2){
//比较 p1节点的值和p2 节点的值 值小的那个 接到p节点的后面
if(p1.val < p2.val){
p.next = p1;
p1 = p1.next;
}else{
p.next = p2;
p2 = p2.next;
}
//每次循环遍历后 p 后移一个节点
p = p.next;
}
// 当出现p1 或者p2 有个为空时，判断哪个为空
// 不为空的接到 p的后面
p.next = p1?p1:p2;
//返回 虚拟头节点的下一个节点
return res.next;
};
题3 剑指 Offer 52. 两个链表的第一个公共节点
这道题非常巧妙。 假设
A： a1->a2->c1
B: b1->b2->b3->c1
当两个链表连接在一起的时候 有两种情况
①：a1->a2->c1->b1->b2->b3->c1
②：b1->b2->b3->c1->a1->a2->c1
就会发现遍历完其中某一个链表的时候，接着遍历下一个链表，当到达相同长度时， 链表最后一个节点 就是公共的节点
下面为双指针解法(目前笔者无法通过数学公式推导出来，只是列举并分析）
/**
* 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 [a,b] = [headA,headB];
while (a != b) {
// a 走一步，如果走到 headA 链表末尾，转到 headB 链表
a = a != null ? a.next : headB;
// b 走一步，如果走到 headB 链表末尾，转到 headA 链表
b = b != null ? b.next : headA;
}
//返回 a
return a;
};
题4 力扣19. 删除链表的倒数第 N 个结点
给你一个链表，删除链表的倒数第 n **个结点，并且返回链表的头结点。
这道题运用了快慢指针的相对距离。
只要保证快指针和慢指针相隔 n 个节点。
在此前提下，当快指针到链表最后一个节点的时候，慢指针刚好到第 n-1 个节点。
接下来就好办了。
/**
* 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) {
//创建虚拟头节点，值为 0 ，next指针域指向head
let dummy = new ListNode(0, head);
//分别用slow fast 指向新创建的虚拟头节点
let [slow, fast] = [dummy, dummy];
let i = 0;
// 当快指针 fast 到链表末尾时停止
while (fast) {
//当快指针 fast 走过了 n 个距离，慢指针 slow 开始后移
if (i > n) slow = slow.next;
fast = fast.next;
i++;
}
//当快指针 fast 到链表末尾，此时快慢指针的相对距离为 n
//此时慢指针指向了第 n-1 个节点
slow.next = slow.next.next;
//返回虚拟头节点的 首元节点
return dummy.next;
};
题5 力扣 876. 链表的中间结点
给定一个头结点为 head 的非空单链表，返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。
解题思路：通过快慢指针的相对距离一次遍历求解
求链表中点，把快指针和慢指针看成两个具有初速度的小车fast和slow，把链表长度看作路程距离
两辆小车同时从头节点出发，小车fast 的速度 是 小车slow 的两倍，当fast小车到达链表的最后一个节点时，小车slow的位置便在 链表的中点。
/**
* 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 middleNode = function (head) {
//定义指针 slow ，fast 指向链表头节点
let [slow, fast] = [head, head];
//当 快指针 以及 快指针的 next域 不为空
while (fast && fast.next) {
slow = slow.next;//慢指针后移一个节点
fast = fast.next.next;//快指针以慢指针两倍的速度后移
}
return slow;
};
题6 力扣 141. 环形链表
给你一个链表的头节点 head ，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ，则返回 true 。 否则，返回 false 。
这道题 只是求证 该链表中到底有没有成环 解题关键 只需要让快指针 fast 是慢指针的两倍速度后移，如果存在环，那快指针必然会先进入环，并在环里面一直移动。当慢指针进入环后，由于环的长度是常量，慢指针每次后移一位，快指针就会后移2位。快慢指针 必然会在慢指针进入环后的第一圈相遇。(相当于快指针每一个时刻都比慢指针走快一个节点，追赶着慢指针)。
/**
* Definition for singly-linked list.
* function ListNode(val) {
* this.val = val;
* this.next = null;
* }
*/
/**
* @param {ListNode} head
* @return {boolean}
*/
var hasCycle = function (head) {
// 快慢指针都指向头节点
let slow = head,
fast = head;
//让快指针fast 每次都后移两个节点
while (fast && fast.next) {
slow = slow.next;
fast = fast.next.next;
//当快慢指针相遇的时候返回 true
if (fast === slow) return true;
}
//没有环则返回false
return false;
};
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。
分析：
这道题是力扣 141. 环形链表的进阶版，重点是需要求出单链表成环的话，环的起点 说实话这道题完全参考了 代码随想录 (programmercarl.com)
/**
* 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 !== null && fast.next !== null) {
//快指针后移两步，慢指针后移一步
fast = fast.next.next;
slow = slow.next;
//当快指针和慢指针相遇的时候退出循环
if (fast === slow) break;
}
//通过快指针 判断是否存在环
if (fast === null || fast.next === null) {
return null;
}
//将慢指针重新指向到头节点
slow = head;
//快指针和慢指针同时后移，求出相交点
while (slow !== fast) {
fast = fast.next;
slow = slow.next;
}
return slow;
};
以上所有题目均来源于力扣（LeetCode）。
