不带环的链表：
1 → 2 → 3 → 4 → 5 → nullptr
快指针先到 nullptr → 无环

带环的链表：
1 → 2 → 3 → 4 → 5 → 3（回到 3）
快指针走两步，慢指针走一步：
1: 快=3, 慢=2
2: 快=5, 慢=3
3: 快=3, 慢=4  ← 回到 3 了！
4: 快=5, 慢=5  ← 相遇！有环

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

bool hasCycle(ListNode* head) {
    if (!head || !head->next) return false;      // ① 空链表或单节点 → 无环

    ListNode* slow = head;                        // ② 慢指针从 head 出发
    ListNode* fast = head;                        // ③ 快指针也从 head 出发

    while (fast && fast->next) {                  // ④ 快指针没到终点就继续
        slow = slow->next;                        // ⑤ 慢指针走一步
        fast = fast->next->next;                  // ⑥ 快指针走两步

        if (slow == fast) {                       // ⑦ 快慢相遇 → 有环
            return true;
        }
    }

    return false;                                 // ⑧ 快指针到尽头 → 无环
}

ListNode* middleNode(ListNode* head) {
    ListNode* slow = head;                        // ① 慢指针从 head 出发
    ListNode* fast = head;                        // ② 快指针也从 head 出发

    while (fast && fast->next) {                  // ③ 快指针能走两步就继续
        slow = slow->next;                        // ④ 慢指针走一步
        fast = fast->next->next;                  // ⑤ 快指针走两步
    }

    return slow;                                  // ⑥ slow 正好在中间
}

height = [1, 8, 6, 2, 5, 4, 8, 3, 7]

初始：left=0 (高度1), right=8 (高度7)
面积 = min(1,7) × (8-0) = 1×8 = 8
移动较矮的那一侧：left++ → left=1 (高度8)

现在：left=1 (高度8), right=8 (高度7)
面积 = min(8,7) × (8-1) = 7×7 = 49  ← 最大！
移动较矮的那一侧：right-- → right=7 (高度3)

继续...

int maxArea(vector<int>& height) {
    int left = 0;                               // ① 左指针指向开头
    int right = height.size() - 1;               // ② 右指针指向末尾
    int max_area = 0;

    while (left < right) {                       // ③ 指针未相遇时循环
        int h = min(height[left], height[right]);// ④ 取较矮的高度
        int w = right - left;                    // ⑤ 计算宽度
        max_area = max(max_area, h * w);         // ⑥ 更新最大面积

        if (height[left] < height[right]) {      // ⑦ 移动较矮的一侧
            left++;
        } else {
            right--;
        }
    }

    return max_area;
}

nums = [-1, 0, 1, 2, -1, -4]

排序后：[-4, -1, -1, 0, 1, 2]

固定第一个数 i，用对撞指针找剩下的两个：
i=0 (-4): 需要在 [-1, -1, 0, 1, 2] 中找两数和为 4
  对撞指针：left=1 (-1), right=5 (2) → sum=-1+2=1，太小 → left++
            left=2 (-1), right=5 (2) → sum=1，太小 → left++
            left=3 (0),  right=5 (2) → sum=2，太小 → left++
            left=4 (1),  right=5 (2) → sum=3 → 找不到

i=1 (-1): 需要在 [-1, 0, 1, 2] 中找两数和为 1
  对撞指针：left=2 (-1), right=5 (2) → sum=1 ✅ 找到 (-1, -1, 2)
            left=3 (0),  right=4 (1) → sum=1 ✅ 找到 (-1, 0, 1)

vector<vector<int>> threeSum(vector<int>& nums) {
    sort(nums.begin(), nums.end());              // ① 排序（对撞指针的前提）
    vector<vector<int>> result;

    for (int i = 0; i < (int)nums.size() - 2; i++) {// ② 固定第一个数
        if (i > 0 && nums[i] == nums[i-1]) continue; // ③ 跳过重复的第一个数

        int left = i + 1;                        // ④ 左指针从 i+1 开始
        int right = nums.size() - 1;              // ⑤ 右指针从末尾开始
        int target = -nums[i];                    // ⑥ 需要找两数和为 -nums[i]

        while (left < right) {                    // ⑦ 对撞指针找两数
            int sum = nums[left] + nums[right];

            if (sum == target) {                  // ⑧ 找到一组解
                result.push_back({nums[i], nums[left], nums[right]});

                while (left < right && nums[left] == nums[left+1]) left++;  // 跳过重复
                while (left < right && nums[right] == nums[right-1]) right--;

                left++;                           // ⑨ 继续找下一组
                right--;
            } else if (sum < target) {
                left++;                           // ⑩ 和太小 → 左指针右移
            } else {
                right--;                          // ⑪ 和太大 → 右指针左移
            }
        }
    }
    return result;
}