【876. 链表的中间结点】

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的公共函数。该函数接收一个指向链表头部的指针，并返回链表的中间节点。下面是对函数中每行代码的解释：

1. vector<ListNode*> A = {head};
   创建一个vector，并将链表头部指针存储在其中。
2. while (A.back()->next != NULL)
   当vector最后一个元素的指针的next成员不为NULL时，循环遍历链表，将链表中所有节点的指针存储在vector中。
3. A.push_back(A.back()->next);
   将链表中下一个节点的指针存储在vector中。
4. 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 指针，它指向链表的中间节点。

请注意，该算法适用于奇数和偶数长度的链表。如果链表的节点数是偶数，则中间节点将是其中两个中间节点的第二个。