feat(src, common): add 19-removeNthFromEnd and reconstruct listHelper

Author: kwu130

include/common.h

@@ -16,34 +16,41 @@ struct ListNode {
     ListNode(int x, ListNode* next)
         : val(x),
           next(next) {}
-    ListNode(const std::vector<int>& vec)
-        : next(nullptr) {
-        assert(!vec.empty());
-        val = vec[0];
-        ListNode* cur = this;
-        for (int i = 1; i < vec.size(); i++) {
-            cur->next = new ListNode(vec[i]);
-            cur = cur->next;
-        }
+};
+
+ListNode* build(const std::vector<int>& vec) {
+    if (vec.empty()) return nullptr;
+    ListNode* head = new ListNode(vec[0]);
+    ListNode* cur = head;
+    for (int i = 1; i < vec.size(); i++) {
+        cur->next = new ListNode(vec[i]);
+        cur = cur->next;
     }
 
-    bool equal(const ListNode* other) const {
-        const ListNode* current_this = this;
-        const ListNode* current_other = other;
+    return head;
+}
 
-        while (current_this != nullptr && current_other != nullptr) {
-            if (current_this->val != current_other->val) {
-                return false;
-            }
-            current_this = current_this->next;
-            current_other = current_other->next;
+bool equal(const ListNode* lhs, const ListNode* rhs) {
+    while (lhs != nullptr && rhs != nullptr) {
+        if (lhs->val != rhs->val) {
+            return false;
         }
+        lhs = lhs->next;
+        rhs = rhs->next;
+    }
+
+    return lhs == nullptr && rhs == nullptr;
+}
 
-        return current_this == nullptr && current_other == nullptr;
+void print(const ListNode* head) {
+    while (head != nullptr) {
+        std::cout << head->val << " -> ";
+        head = head->next;
     }
-};
+    std::cout << "nullptr" << std::endl;
+}
 
-void freeList(ListNode* head) {
+void free(ListNode* head) {
     while (head != nullptr) {
         ListNode* tmp = head;
         head = head->next;
@@ -52,6 +59,7 @@ void freeList(ListNode* head) {
 }
 }  // namespace listHelper
 
+
 namespace compareHelper {
 template <typename T>
 bool equalIgnoreOrder(std::vector<std::vector<T>> a, std::vector<std::vector<T>> b) {

src/19-removeNthFromEnd.cpp

@@ -0,0 +1,63 @@
+//
+// Created by 1412 on 2025/10/15.
+//
+
+#include <bits/stdc++.h>
+#include "../include/common.h"
+
+using namespace std;
+using listHelper::ListNode;
+
+class Solution {
+public:
+    ListNode* removeNthFromEnd(ListNode* head, int n) {
+        ListNode *pre, *first, *second;
+        pre = nullptr;
+        first = second = head;
+        while (n--) {
+            first = first->next;
+        }
+        while (first != nullptr) {
+            first = first->next;
+            pre = second;
+            second = second->next;
+        }
+        if (pre == nullptr) {
+            head = head->next;
+        } else {
+            pre->next = second->next;
+        }
+        delete second;
+
+        return head;
+    }
+};
+
+void test() {
+    Solution s;
+    ListNode* head = listHelper::build({1, 2, 3, 4, 5});
+    ListNode* expected = listHelper::build({1, 2, 3, 5});
+    ListNode* res = s.removeNthFromEnd(head, 2);
+    assert(listHelper::equal(res, expected));
+    listHelper::free(res);
+    listHelper::free(expected);
+
+    head = listHelper::build({1});
+    expected = nullptr;
+    res = s.removeNthFromEnd(head, 1);
+    assert(listHelper::equal(res, expected));
+    listHelper::free(res);
+    listHelper::free(expected);
+
+    head = listHelper::build({1, 2});
+    expected = listHelper::build({1});
+    res = s.removeNthFromEnd(head, 1);
+    assert(listHelper::equal(res, expected));
+    listHelper::free(res);
+    listHelper::free(expected);
+}
+
+int main() {
+    test();
+    return 0;
+}

src/2-addTwoNumbers.cpp

@@ -6,7 +6,7 @@
 #include "../include/common.h"
 
 using namespace std;
-using namespace listHelper;
+using listHelper::ListNode;
 
 class Solution {
 public:
@@ -30,32 +30,36 @@ class Solution {
 
 void test() {
     Solution s;
-    ListNode* l1 = new ListNode(vector<int>{2, 4, 3});
-    ListNode* l2 = new ListNode(vector<int>{5, 6, 4});
-    ListNode* expected = new ListNode(vector<int>{7, 0, 8});
+    ListNode* l1 = listHelper::build({2, 4, 3});
+    ListNode* l2 = listHelper::build({5, 6, 4});
+    ListNode* expected = listHelper::build({7, 0, 8});
     ListNode* res = s.addTwoNumbers(l1, l2);
-    assert(res->equal(expected));
-    freeList(l1);
-    freeList(l2);
-    freeList(expected);
 
-    l1 = new ListNode(vector<int>{0});
-    l2 = new ListNode(vector<int>{0});
-    expected = new ListNode(vector<int>{0});
+    assert(listHelper::equal(res, expected));
+    listHelper::free(l1);
+    listHelper::free(l2);
+    listHelper::free(res);
+    listHelper::free(expected);
+
+    l1 = listHelper::build({0});
+    l2 = listHelper::build({0});
+    expected = listHelper::build({0});
     res = s.addTwoNumbers(l1, l2);
-    assert(res->equal(expected));
-    freeList(l1);
-    freeList(l2);
-    freeList(expected);
+    assert(listHelper::equal(res, expected));
+    listHelper::free(l1);
+    listHelper::free(l2);
+    listHelper::free(res);
+    listHelper::free(expected);
 
-    l1 = new ListNode(vector<int>{9, 9, 9, 9, 9, 9, 9});
-    l2 = new ListNode(vector<int>{9, 9, 9, 9});
-    expected = new ListNode(vector<int>{8, 9, 9, 9, 0, 0, 0, 1});
+    l1 = listHelper::build({9, 9, 9, 9, 9, 9, 9});
+    l2 = listHelper::build({9, 9, 9, 9});
+    expected = listHelper::build({8, 9, 9, 9, 0, 0, 0, 1});
     res = s.addTwoNumbers(l1, l2);
-    assert(res->equal(expected));
-    freeList(l1);
-    freeList(l2);
-    freeList(expected);
+    assert(listHelper::equal(res, expected));
+    listHelper::free(l1);
+    listHelper::free(l2);
+    listHelper::free(res);
+    listHelper::free(expected);
 }
 
 int main() {