feat(src): add 22-generateParenthesis, 23-mergeKLists, 24-swapPairs, 25-reverseKGroup

Author: kwu130

src/22-generateParenthesis.cpp

@@ -0,0 +1,48 @@
+//
+// Created by 1412 on 2025/10/16.
+//
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class Solution {
+public:
+    vector<string> generateParenthesis(int n) {
+        vector<string> res;
+        dfs(res, "", n, n);
+        return res;
+    }
+
+private:
+    void dfs(vector<string>& res, string&& path, int l, int r) {
+        if (l == 0 && r == 0) {
+            res.push_back(path);
+            return;
+        }
+        if (l > 0) {
+            path.push_back('(');
+            dfs(res, std::move(path), l - 1, r);
+            path.pop_back();
+        }
+        if (l < r) {
+            path.push_back(')');
+            dfs(res, std::move(path), l, r - 1);
+            path.pop_back();
+        }
+    }
+};
+
+void test() {
+    Solution s;
+    vector<string> expected = {"((()))", "(()())", "(())()", "()(())", "()()()"};
+    assert(s.generateParenthesis(3) == expected);
+
+    expected = {"()"};
+    assert(s.generateParenthesis(1) == expected);
+}
+
+int main() {
+    test();
+    return 0;
+}

src/23-mergeKLists.cpp

@@ -0,0 +1,68 @@
+//
+// Created by 1412 on 2025/10/16.
+//
+
+#include <bits/stdc++.h>
+#include "../include/common.h"
+
+using namespace std;
+using listHelper::ListNode;
+
+class Solution {
+public:
+    ListNode* mergeKLists(vector<ListNode*>& lists) {
+        auto cmp = [](ListNode* lhs, ListNode* rhs) { return lhs->val > rhs->val; };
+        priority_queue<ListNode*, vector<ListNode*>, decltype(cmp)> pq(cmp);
+        for (auto list : lists) {
+            if (list) {
+                pq.push(list);
+            }
+        }
+
+        ListNode* dummy = new ListNode(-1);
+        ListNode* cur = dummy;
+        while (!pq.empty()) {
+            auto node = pq.top();
+            pq.pop();
+            cur->next = node;
+            cur = cur->next;
+            if (node->next) {
+                pq.push(node->next);
+            }
+        }
+
+        return dummy->next;
+    }
+};
+
+void test() {
+    Solution s;
+    ListNode* l1 = listHelper::build({1, 4, 5});
+    ListNode* l2 = listHelper::build({1, 3, 4});
+    ListNode* l3 = listHelper::build({2, 6});
+    vector<ListNode*> lists = {l1, l2, l3};
+    ListNode* expected = listHelper::build({1, 1, 2, 3, 4, 4, 5, 6});
+    ListNode* res = s.mergeKLists(lists);
+    assert(listHelper::equal(res, expected));
+    listHelper::free(res);
+    listHelper::free(expected);
+
+    lists = {};
+    expected = listHelper::build({});
+    res = s.mergeKLists(lists);
+    assert(listHelper::equal(res, expected));
+    listHelper::free(res);
+    listHelper::free(expected);
+
+    lists = {nullptr};
+    expected = listHelper::build({});
+    res = s.mergeKLists(lists);
+    assert(listHelper::equal(res, expected));
+    listHelper::free(res);
+    listHelper::free(expected);
+}
+
+int main() {
+    test();
+    return 0;
+}

src/24-swapPairs.cpp

@@ -0,0 +1,58 @@
+//
+// Created by 1412 on 2025/10/16.
+//
+
+#include <bits/stdc++.h>
+#include "../include/common.h"
+
+using namespace std;
+using listHelper::ListNode;
+
+class Solution {
+public:
+    ListNode* swapPairs(ListNode* head) {
+        if (head == nullptr || head->next == nullptr) return head;
+        ListNode* dummy = new ListNode(-1);
+        dummy->next = head;
+        ListNode *pre = dummy, *cur = head;
+        while (cur != nullptr && cur->next != nullptr) {
+            ListNode* next = cur->next;
+            pre->next = next;
+            cur->next = next->next;
+            next->next = cur;
+            pre = cur;
+            cur = cur->next;
+        }
+
+        return dummy->next;
+    }
+};
+
+void test() {
+    Solution s;
+    ListNode* l1 = listHelper::build({1, 2, 3, 4});
+    ListNode* expected = listHelper::build({2, 1, 4, 3});
+    ListNode* res = s.swapPairs(l1);
+    assert(listHelper::equal(res, expected));
+    listHelper::free(res);
+    listHelper::free(expected);
+
+    l1 = listHelper::build({});
+    expected = listHelper::build({});
+    res = s.swapPairs(l1);
+    assert(listHelper::equal(res, expected));
+    listHelper::free(res);
+    listHelper::free(expected);
+
+    l1 = listHelper::build({1});
+    expected = listHelper::build({1});
+    res = s.swapPairs(l1);
+    assert(listHelper::equal(res, expected));
+    listHelper::free(res);
+    listHelper::free(expected);
+}
+
+int main() {
+    test();
+    return 0;
+}

src/25-reverseKGroup.cpp

@@ -0,0 +1,67 @@
+//
+// Created by 1412 on 2025/10/16.
+//
+
+#include <bits/stdc++.h>
+#include "../include/common.h"
+
+using namespace std;
+using listHelper::ListNode;
+
+class Solution {
+public:
+    ListNode* reverseKGroup(ListNode* head, int k) {
+        if (head == nullptr || head->next == nullptr || k == 1) return head;
+        ListNode* tail = head;
+        for (int i = 0; i < k; i++) {
+            // There are less than k nodes in the list, do nothing.
+            if (tail == nullptr) return head;
+            tail = tail->next;
+        }
+        ListNode* newHead = reverseInterval(head, tail);
+        head->next = reverseKGroup(tail, k);
+        return newHead;
+    }
+
+private:
+    // reverse [head, tail)
+    ListNode* reverseInterval(ListNode* head, ListNode* tail) {
+        ListNode *pre = nullptr, *cur = head;
+        while (cur != tail) {
+            ListNode* next = cur->next;
+            cur->next = pre;
+            pre = cur;
+            cur = next;
+        }
+        return pre;
+    }
+};
+
+void test() {
+    Solution s;
+    ListNode* l1 = listHelper::build({1, 2, 3, 4, 5});
+    ListNode* expected = listHelper::build({2, 1, 4, 3, 5});
+    ListNode* res = s.reverseKGroup(l1, 2);
+    assert(listHelper::equal(res, expected));
+    listHelper::free(res);
+    listHelper::free(expected);
+
+    l1 = listHelper::build({1, 2, 3, 4, 5});
+    expected = listHelper::build({3, 2, 1, 4, 5});
+    res = s.reverseKGroup(l1, 3);
+    assert(listHelper::equal(res, expected));
+    listHelper::free(res);
+    listHelper::free(expected);
+
+    l1 = listHelper::build({1, 2, 3, 4, 5});
+    expected = listHelper::build({5, 4, 3, 2, 1});
+    res = s.reverseKGroup(l1, 5);
+    assert(listHelper::equal(res, expected));
+    listHelper::free(res);
+    listHelper::free(expected);
+}
+
+int main() {
+    test();
+    return 0;
+}