这道题要求在升序链表中删除所有重复出现的元素，仅保留只出现一次的节点，可以通过 双指针遍历。遍历链表时，先通过内层循环让cur跳到当前值的最后一个重复节点，然后判断pre的后继是否是cur—— 如果是，说明该节点有效，pre向前推进；如果不是，说明当前值是重复元素，直接让pre的后继指向cur的下一个节点，最后cur继续推进遍历。ListNode* deleteDuplicates(ListNode* head) {if (head == nullptr || head->next == nullptr) {return head;}ListNode* dummy = new ListNode(0);dummy->next = head;ListNode* pre = dummy;ListNode* cur = head;while (cur != nullptr) {while (cur->next != nullptr && cur->val == cur->next->val) {cur = cur->next;}if (pre->next == cur) {pre = pre->next;} else {pre->next = cur->next;}cur = cur->next;}ListNode* newhead = dummy->next;delete dummy;return newhead;}该解法的时间复杂度为 O (n)，空间复杂度为 O (1)

核心思路是先统计链表总长度，确定需要反转的组数，再逐组局部反转并重新连接，计算出需要反转的组数s = n/k；然后循环s次，每次对当前 k 个节点进行局部反转，反转后将当前组的首尾与前后部分重新连接，最后返回处理后的链表头。对应的代码解析如下：class Solution {public:ListNode* reverseKGroup(ListNode* head, int k) {if(!head || k == 1) return head; // 空链表或k=1无需反转ListNode* dummy = new ListNode(0); // 虚拟头节点，简化头节点处理dummy->next = head;ListNode* cur = head;ListNode* pre = dummy; // 记录上一组的尾节点ListNode* next = nullptr;ListNode* prev = nullptr;ListNode* temp = nullptr; // 记录当前组反转前的头节点int n = 0;while(cur != nullptr) {n++;cur = cur->next;}cur = head;if(n == 1) return head; // 只有1个节点直接返回int s = n / k; // 计算需要反转的组数while(s--) {for(int i = 0; i < k; i++) {if(i == 0) temp = cur; // 记录当前组反转前的头节点next = cur->next;cur->next = prev; // 当前节点指向前一个反转节点prev = cur;cur = next;}pre->next = prev;temp->next = cur;pre = temp; // 更新上一组的尾节点为当前组反转前的头节点prev = nullptr; // 重置反转前驱指针}ListNode* newhead = dummy->next;delete dummy; // 释放虚拟头节点，避免内存泄漏return newhead;}};该解法的时间复杂度为 O (n)，空间复杂度为 O (1)。

这道题要求合并 k 个已排序的链表为一个新的有序链表，用数组排序 + 重建链表首先，遍历所有输入链表，将每个节点的数值收集到一个数组中。接着对数组进行排序，利用排序后的数组重新构建一个新的有序链表以下是对应的代码解析：class Solution {public:ListNode* mergeKLists(vector<ListNode*>& lists) {vector<int> a; // 存储所有链表节点的数值// 遍历所有链表，收集节点值for (auto node : lists) {ListNode* p = node;while (p != NULL) {a.push_back(p->val);p = p->next;}}sort(a.begin(), a.end()); // 对数值进行排序ListNode dummy(0); // 虚拟头节点，简化链表构建ListNode* q = &dummy;// 用排序后的数值重建有序链表for (int val : a) {q->next = new ListNode(val);q = q->next;}return dummy.next; // 返回新链表的头节点}};该解法的时间复杂度为O(NlogN)，空间复杂度为O(N)。

首先处理特殊情况：若 m 和 n 相等无需反转，直接返回原链表。然后用一个虚拟头节点dummy简化头节点的处理，先找到反转区间的前驱节点，再定位到反转区间的起始节点cur。然后进行局部反转，循环将节点之间的链接断开并反向连接，逐步推进指针完成 m 到 n 区间的反转。反转完成后，需要将反转区间的首尾与原链表重新连接。以下是对应的代码：class Solution {public:ListNode* reverseBetween(ListNode* head, int m, int n) {if (m == n) return head;ListNode dummy(0);dummy.next = head;ListNode* pre = &dummy;ListNode* t = pre;// 找到反转区间的前驱节点for (int i = 1; i < m; ++i) {t = t->next;}ListNode* cur = t->next; // 反转区间的起始节点ListNode* next = cur->next; // 记录原链表的后继ListNode* NU = nullptr;// 局部反转m到n的区间for (int i = m; i < n; ++i) {cur->next = NU;NU = cur;         //断开链接pre = cur;cur = next;       // 推进当前节点next = cur->next; // 记录下一个节点cur->next = pre;  // 完成当前步反转}// 重新连接反转区间的首尾t->next->next = next;t->next = cur;return dummy.next;  }};该代码的时间复杂度为 O (n)，空间复杂度为 O (1)

这道题要求找出数组中每个大小为size的滑动窗口内的最大值。我们可以通过暴力遍历每个窗口并直接查找最大值的方式解决。首先处理特殊情况：若窗口大小size为 0，直接返回空数组。对于有效窗口，外层循环遍历所有可能的窗口起始位置（共num.size()-size+1个窗口），内层循环逐个比较窗口内的元素，记录每个窗口的最大值。最后将所有窗口的最大值收集到结果数组中返回。以下是对应的实现代码：include <queue>using namespace std;class Solution {public:vector<int> maxInWindows(vector<int>& num, int size) {vector<int> ans;// 处理窗口大小为0的特殊情况if (size == 0) return ans;queue<int> nums;// 遍历所有滑动窗口的起始位置for (int i = 0; i < num.size() - size + 1; i++) {int max = 0;// 遍历当前窗口内的元素，找到最大值for (int j = i; j < i + size; j++) {if (num[j] > max) max = num[j];}nums.push(max);}// 将队列中的最大值转移到结果数组while (!nums.empty()) {ans.push_back(nums.front());nums.pop();}return ans;}};该代码的时间复杂度为O(n×size)，空间复杂度为O(n)。