Leetcode
876. 链表的中间结点
给你单链表的头结点 head ，请你找出并返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。
示例 1：
输入：head = [1,2,3,4,5]
输出：[3,4,5]
解释：链表只有一个中间结点，值为 3 。
示例 2：
输入：head = [1,2,3,4,5,6]
输出：[4,5,6]
解释：该链表有两个中间结点，值分别为 3 和 4 ，返回第二个结点。
提示：
链表的结点数范围是 [1, 100]
1 <= Node.val <= 100
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/middle-of-the-linked-list
方法一：数组
思路和算法
链表的缺点在于不能通过下标访问对应的元素。因此我们可以考虑对链表进行遍历，同时将遍历到的元素依次放入数组 A 中。如果我们遍历到了 N 个元素，那么链表以及数组的长度也为 N，对应的中间节点即为 A[N/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) {}
* };
*/
class Solution {
public:
ListNode* middleNode(ListNode* head) {
vector<ListNode*> A = {head}; // 创建一个vector，并将链表头部指针存储在其中
while (A.back()->next != NULL) // 遍历链表，将链表中所有节点的指针存储在vector中
A.push_back(A.back()->next);
return A[A.size() / 2]; // 找到vector的中间元素，并返回其指针作为中间节点
}
};
复杂度分析
- 时间复杂度：O(N)，其中 N 是给定链表中的结点数目。
- 空间复杂度：O(N)，即数组 A 用去的空间。
这段代码定义了一个名为Solution的类，其中包含一个名为middleNode的公共函数。该函数接收一个指向链表头部的指针，并返回链表的中间节点。下面是对函数中每行代码的解释：
vector<ListNode*> A = {head};
创建一个vector，并将链表头部指针存储在其中。while (A.back()->next != NULL)
当vector最后一个元素的指针的next成员不为NULL时，循环遍历链表，将链表中所有节点的指针存储在vector中。A.push_back(A.back()->next);
将链表中下一个节点的指针存储在vector中。return A[A.size() / 2];
找到vector的中间元素，并返回其指针作为中间节点。
vector<ListNode*> A = {head};解释 {}
vector<ListNode*> A = {head}; 是使用C++11中的列表初始化语法来创建一个vector对象A，并将指向链表头节点的指针head添加到A中的语句。
在C++中，花括号{}用于列表初始化，可以用于初始化各种类型的变量，包括数组、结构体、STL容器等。在这里，我们使用列表初始化创建了一个vector对象A，它的元素类型是指向ListNode类型的指针。head是一个指向链表头节点的指针，我们将其添加到vector中作为第一个元素。
这个语句等价于以下代码：
vector<ListNode*> A;
A.push_back(head);
这样，我们就创建了一个vector对象A，并将链表头部指针存储在其中，以便后续遍历。
解释A.back()->next
A.back()是vector A的最后一个元素的地址，A.back()->next表示最后一个元素所指向的下一个节点的地址。
在这段代码中，vector<ListNode*> A 中存储了链表中所有节点的指针，A.back()返回的是vector中最后一个元素即链表的最后一个节点的指针。如果最后一个节点的next成员不为NULL，即链表还没有遍历到最后一个节点，那么就将最后一个节点的下一个节点的指针加入vector中。这样，当vector中最后一个元素的next成员为NULL时，就可以确定链表的最后一个节点是vector中的最后一个元素，遍历结束。
因此，A.back()->next表示最后一个节点所指向的下一个节点的地址，如果最后一个节点的next成员为NULL，则表示链表遍历结束。
A.push_back(A.back()->next);解释
A.push_back(A.back()->next) 是将链表中下一个节点的指针存储在vector中的语句。
在这里，A.back()返回的是vector中的最后一个元素，即链表的最后一个节点的指针。A.back()->next表示最后一个节点所指向的下一个节点的指针。将这个指针添加到vector中，就可以继续遍历链表的下一个节点。
这个语句等价于以下代码：
ListNode* next = A.back()->next;
A.push_back(next);
这样，我们就将链表中下一个节点的指针存储在vector中，以便后续遍历。
解释A[A.size() / 2]
A[A.size() / 2] 用于访问链表的中间节点。
A 是一个存储从头节点开始的所有链表节点指针的向量。表达式 A.size() 返回向量 A 中的元素数量。
因为我们要找到链表的中间节点，所以我们需要返回向量 A 中索引为 A.size() / 2 的节点指针。由于向量的索引从 0 开始，A.size() / 2 是向量的中间元素的索引。因此，A[A.size() / 2] 返回链表的中间节点指针。
[] 运算符用于通过索引访问向量中的元素。在这种情况下，A[A.size() / 2] 使用 [] 运算符访问向量 A 中索引为 A.size() / 2 的元素，即链表的中间节点指针。
举例子:链表 1 -> 2 -> 3 -> 4 -> 5
假设有一个链表 1 -> 2 -> 3 -> 4 -> 5，其中数字表示节点的值。我们将这个链表传递给 middleNode 函数。
在函数内部，首先创建一个指向头节点的指针 head，然后将其存储在一个向量 A 中。向量 A 现在包含一个元素，即指向节点 1 的指针。
接下来，函数进入一个循环，遍历整个链表，将所有节点的指针存储在向量 A 中。在循环的第一次迭代中，A.back() 将返回指向节点 1 的指针。由于节点 1 的 next 指针指向节点 2，因此将指向节点 2 的指针添加到向量 A 中。在循环的第二次迭代中，A.back() 将返回指向节点 2 的指针，然后指向节点 3 的指针将被添加到向量 A 中。以此类推，直到所有节点的指针都被添加到向量 A 中。
现在，我们需要返回链表的中间节点。由于向量 A 包含所有节点的指针，并且已经按顺序存储，我们可以使用 A[A.size() / 2] 访问向量的中间元素。在这种情况下，A.size() 是 5，因此 A.size() / 2 是 2。因此，A[2] 将返回指向节点 3 的指针，这是链表的中间节点。
最后，函数将指向节点 3 的指针作为结果返回。
举例子:链表 1 -> 2 -> 3 -> 4 -> 5->6
假设有一个链表 1 -> 2 -> 3 -> 4 -> 5 -> 6，其中数字表示节点的值。我们将这个链表传递给 middleNode 函数。
在函数内部，首先创建一个指向头节点的指针 head，然后将其存储在一个向量 A 中。向量 A 现在包含一个元素，即指向节点 1 的指针。
接下来，函数进入一个循环，遍历整个链表，将所有节点的指针存储在向量 A 中。在循环的第一次迭代中，A.back() 将返回指向节点 1 的指针。由于节点 1 的 next 指针指向节点 2，因此将指向节点 2 的指针添加到向量 A 中。在循环的第二次迭代中，A.back() 将返回指向节点 2 的指针，然后指向节点 3 的指针将被添加到向量 A 中。以此类推，直到所有节点的指针都被添加到向量 A 中。
现在，我们需要返回链表的中间节点。由于向量 A 包含所有节点的指针，并且已经按顺序存储，我们可以使用 A[A.size() / 2] 访问向量的中间元素。在这种情况下，A.size() 是 6，因此 A.size() / 2 是 3。因此，A[3] 将返回指向节点 4 的指针，这是链表的中间节点。
最后，函数将指向节点 4 的指针作为结果返回。
下面是带有打印语句的代码示例：
#include <iostream>
#include <vector>
using namespace std;
// 链表节点定义
struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
public:
ListNode* middleNode(ListNode* head) {
vector<ListNode*> A = {head}; // 创建一个vector，并将链表头部指针存储在其中
while (A.back()->next != NULL) // 遍历链表，将链表中所有节点的指针存储在vector中
A.push_back(A.back()->next);
return A[A.size() / 2]; // 找到vector的中间元素，并返回其指针作为中间节点
}
};
int main() {
// 创建链表 1->2->3->4->5->6
ListNode *head = new ListNode(1);
ListNode *current = head;
for (int i = 2; i <= 6; i++) {
current->next = new ListNode(i);
current = current->next;
}
// 打印链表中的元素
ListNode *current = head;
while (current != NULL) {
cout << current->val << " ";
current = current->next;
}
cout << endl;
// 调用middleNode函数
Solution solution;
ListNode *middle = solution.middleNode(head);
// 打印链表中所有节点的值
vector<ListNode*> A = {head};
for (auto node : A) {
cout << node->val << " ";
}
cout << endl;
// 打印链表的中间节点值
cout << "Middle Node Value: " << middle->val << endl;
return 0;
}
输出应该是：
1 2 3 4 5 6
1 2 3 4 5 6
Middle Node Value: 4
方法二：单指针法
我们可以对方法一进行空间优化，省去数组 A。
我们可以对链表进行两次遍历。第一次遍历时，我们统计链表中的元素个数 N；第二次遍历时，我们遍历到第 N/2 个元素（链表的首节点为第 0 个元素）时，将该元素返回即可。
作者：LeetCode-Solution
链接：https://leetcode.cn/problems/middle-of-the-linked-list/solution/lian-biao-de-zhong-jian-jie-dian-by-leetcode-solut/
class Solution {
public:
ListNode* middleNode(ListNode* head) {
int n = 0; // 定义变量 n，用来记录链表的长度
ListNode* cur = head; // 定义指针 cur，初始指向头节点
while (cur != nullptr) { // 循环遍历链表，计算链表的长度
++n; // 计数器 n 加 1
cur = cur->next; // 指针 cur 移动到下一个节点
}
int k = 0; // 定义变量 k，用来记录当前遍历到的节点位置
cur = head; // 指针 cur 再次指向头节点
while (k < n / 2) { // 循环遍历链表，找到中间节点的位置
++k; // 计数器 k 加 1
cur = cur->next; // 指针 cur 移动到下一个节点
}
return cur; // 返回指向中间节点的指针 cur
}
};
复杂度分析
- 时间复杂度：O(N)，其中 N 是给定链表的结点数目。
- 空间复杂度：O(1)，只需要常数空间存放变量和指针。
方法三：快慢指针法
思路和算法
我们可以继续优化方法二，用两个指针 slow 与 fast 一起遍历链表。slow 一次走一步，fast 一次走两步。那么当 fast 到达链表的末尾时，slow 必然位于中间。
作者：LeetCode-Solution
链接：https://leetcode.cn/problems/middle-of-the-linked-list/solution/lian-biao-de-zhong-jian-jie-dian-by-leetcode-solut/
ListNode* middleNode(ListNode* head) {
// 初始化两个指针，都指向链表的头节点
ListNode* slow = head;
ListNode* fast = head;
// 当 fast 指针不为空且 fast->next 指针不为空时循环
while (fast != NULL && fast->next != NULL) {
// slow 指针向前移动一个节点
slow = slow->next;
// fast 指针向前移动两个节点
fast = fast->next->next;
}
// 返回 slow 指针，即为链表的中间节点
return slow;
}
复杂度分析
- 时间复杂度：O(N)，其中 N 是给定链表的结点数目。
- 空间复杂度：O(1)，只需要常数空间存放 slow 和 fast 两个指针
算法使用两个指针，slow 和 fast。最初，两个指针都设置为链表的头部。 fast 指针移动的速度是 slow 指针的两倍。当 fast 到达链表的末尾时，slow 将会在链表的中间。
while 循环会一直进行，只要 fast 指针不为 NULL 并且 fast->next 指针也不为 NULL。如果 fast 指针变成 NULL，循环就会结束。如果 fast->next 变成 NULL，fast 将指向链表的最后一个节点，而 slow 将指向链表的中间节点。
在 while 循环结束后，函数返回 slow 指针，它指向链表的中间节点。
请注意，该算法适用于奇数和偶数长度的链表。如果链表的节点数是偶数，则中间节点将是其中两个中间节点的第二个。
