Leetcode 876. 链表的中间结点
问题：给你单链表的头结点 head ，请你找出并返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。
、
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/算法：
快慢指针，快指针 fast 移动两个元素位置，慢指针 slow 移动一个元素位置。
当元素个数为奇数时，快指针 fast 指向最后一个结点时，慢指针 slow 正好位于中间结点处。
当元素个数为偶数时，快指针 fast 指向空时，慢指针 slow 正好位于第二个中间结点处。
代码：
struct ListNode* middleNode(struct ListNode* head){
ListNode *fast=head,*slow=head;
while(fast&&fast->next){
slow=slow->next;
fast=fast->next->next;
}
return slow;
}Leetcode 141. 环形链表
问题：给你一个链表的头节点 head ，判断链表中是否有环。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ，则返回 true 。 否则，返回 false 。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/算法：
如果有环的话，那么慢指针 slow 和快指针 fast 都会进入环中。这时用相对速度思考，乌慢指针 slow 不动，快指针 fast 相对慢指针 slow 每次只走一步，这样就可以看出快指针 fast 一定会和慢指针 slow 相遇了。
代码：
class Solution {
public:
bool hasCycle(ListNode *head) {
ListNode *fast = head,*slow = head;
while(fast && fast->next){
slow = slow->next;
fast = fast->next->next;
if(fast == slow) return true;
}
return false;
}
};Leetcode 142. 环形链表 II
问题：给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/算法：
快慢指针，慢指针 slow 追上快指针 fast 时，慢指针 slow 一定没有走完一整圈，因为慢指针 slow 和快指针 fast 相对速度是 1 ，所以最坏情况是慢指针入环后再走环长度 - 1 的距离。
列出等式后可推得：从头结点 head 到环入口的距离 a - 慢指针 slow 入环后走的距离 c = n 倍的环长。
代码：
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode *slow = head,*fast = head;
while(fast && fast->next){
slow = slow->next;
fast = fast->next->next;
if(fast == slow){// 快慢指针相遇
while(slow != head){
slow = slow->next;
head = head->next;
}
return slow;
}
}
return nullptr;
}
};Leetcode 143. 重排链表
问题：
给定一个单链表 L 的头节点 head ，单链表 L 表示为：
L0 → L1 → … → Ln - 1 → Ln
请将其重新排列后变为：
L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …
不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
/**
* 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) {}
* };
*/算法：先找到链表的中间结点 mid
反转后半段链表
代码：
class Solution {
// 链表的中间结点
ListNode *middleNode(ListNode *head) {
ListNode *slow = head, *fast = head;
while (fast && fast->next) {
slow = slow->next;
fast = fast->next->next;
}
return slow;
}
// 反转链表
ListNode *reverseList(ListNode *head) {
ListNode *pre = nullptr, *cur = head;
while (cur) {
ListNode *nxt = cur->next;
cur->next = pre;
pre = cur;
cur = nxt;
}
return pre;
}
public:
void reorderList(ListNode* head) {
ListNode *mid = middleNode(head);// 找出中间结点 mid
ListNode *head2 = reverseList(mid);// 反转后半段链表
while(head2->next){
ListNode *nxt = head->next,*nxt2 = head2->next;
head->next = head2;
head2->next = nxt;
head = nxt;
head2 = nxt2;
}
}
};
