文档讲解：虚拟头节点，三指针，快慢指针，链表相交，环形链表，
技巧：
1、对于指针的操作要画图，明确步骤后好做了
2、使用虚拟头节点可以避免对头节点单独讨论，且方便对头节点操作
24. 两两交换链表中的节点
两两交换需要使用三指针分别指向连续链接的节点，在前两节点交换时不会丢失第三节点（指针操作复杂，要明确每一步操作）
使用虚拟头节点可以避免对头节点单独讨论
三指针：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
ListNode * dummyNode = new ListNode(0);
dummyNode->next = head;
ListNode * left = dummyNode;
ListNode * cur = dummyNode->next;
ListNode * right;
while(cur != nullptr){
right = cur->next;
if(right == nullptr) break;
cur->next = right->next;
right->next = cur;
left->next = right;
left = cur;
cur = cur->next;
}
return dummyNode->next;
}
};
19.删除链表的倒数第N个节点
定义fast指针和slow指针，初始值为虚拟头结点
fast首先走n + 1步 ，同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作）
快慢指针
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode * dummyNode = new ListNode(0);
dummyNode->next = head;
ListNode * slow = dummyNode, * fast = dummyNode;
int i = 0;
while(i <= n){
if(fast == nullptr) return nullptr;
fast = fast->next;
i++;
}
ListNode * temp = slow;
slow = slow->next;//slow为头节点，fast指向第n+1个节点
while(fast != nullptr){
fast = fast->next;
temp = slow;
slow = slow->next;
}
temp->next = slow->next;//可能删除head
delete slow;
return dummyNode->next;//因为head可能被删除，但dummy的next会指向新head
}
};
面试题 02.07. 链表相交
求出两个链表长度的差值L；
然后根据差值将两链表的遍历指针的起始位置对齐，即较长链表的指针需先走L步；
若存在交点，则必为第一次两指针相同的位置（注意不是元素值相同处）
快慢指针
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
int lenA = 0, lenB = 0;
ListNode * NodeA = headA, *NodeB = headB;
while(NodeA != nullptr || NodeB != nullptr){
if(NodeA != nullptr){
lenA++;
NodeA = NodeA->next;
}
if(NodeB != nullptr){
lenB++;
NodeB = NodeB->next;
}
}
int len = lenA > lenB? lenA-lenB:lenB-lenA;
if(lenA - lenB > 0){
NodeA = headA;
NodeB = headB;
}
else{
NodeA = headB;//NodeA一定指向较长链表的头节点
NodeB = headA;
}
for(int i = 0; i < len; i++){
NodeA = NodeA->next;
}
while(NodeA != nullptr){
if(NodeA == NodeB) return NodeA;
NodeA = NodeA->next;
NodeB = NodeB->next;
}
return nullptr;
}
};
142.环形链表II
1、使用两个指针，fast和low指针遍历链表，fast每次前进两步，low每次前进一步。
2、第一次相遇后，将两指针分别从head和相遇点同时前进，每次前进一步，则必相交于环入口。{原因：x = （n -1）(y + z) + z}
已经确定有环时，如何确定环入口：
假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点再到环形入口节点节点数为 z。 如图所示：
那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈环内节点的个数。
因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：(x + y) * 2 = x + y + n (y + z)
因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。
整理得：x = （n -1）(y + z) + z 表示从头结点出发一个指针node1，从相遇节点也出发一个指针node2，步进均为1，node1走x到环入口时，node2走n-1圈环后又z正好也走到环入口。
注意：n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针
快慢指针
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode * slow = head, * fast = head;
while(fast != nullptr && fast->next != nullptr){
fast = fast->next->next;
slow = slow->next;
if(slow == fast) {
slow = head;
while(slow != fast){
slow = slow->next;
fast = fast->next;
}
return slow;
}
}
return nullptr;
}
};
