C++链表的虚拟头节点实现细节及注意事项

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x = 0) : val(x), next(nullptr) {}  // 构造函数支持默认值
};

void insertAtHead(ListNode*& head, int val) {
    ListNode* newNode = new ListNode(val);
    if (head == nullptr) {  // 空链表特殊处理
        head = newNode;
        return;
    }
    newNode->next = head;
    head = newNode;
}

void insertAtHeadWithDummy(ListNode* dummy, int val) {
    ListNode* newNode = new ListNode(val);
    newNode->next = dummy->next;  // 新节点指向原头节点
    dummy->next = newNode;        // 虚拟头节点指向新节点
    // 无需处理空链表，dummy->next初始为nullptr，插入后变为新节点
}

bool deleteHead(ListNode*& head) {
    if (head == nullptr) return false;  // 空链表无节点可删
    ListNode* temp = head;
    head = head->next;
    delete temp;
    return true;
}

bool deleteHeadWithDummy(ListNode* dummy) {
    if (dummy->next == nullptr) return false;  // 真实头节点为空
    ListNode* temp = dummy->next;
    dummy->next = temp->next;
    delete temp;
    return true;
}

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    ListNode* dummy = new ListNode(0);  // 虚拟头节点，值0无意义
    ListNode* curr = dummy;
    while (l1 && l2) {
        if (l1->val < l2->val) {
            curr->next = l1;
            l1 = l1->next;
        } else {
            curr->next = l2;
            l2 = l2->next;
        }
        curr = curr->next;
    }
    // 连接剩余链表
    curr->next = (l1 != nullptr) ? l1 : l2;
    ListNode* result = dummy->next;
    delete dummy;  // 释放虚拟头节点
    return result;
}

ListNode* dummy = new ListNode(-1);  // 值可任意，通常设为-1或0
dummy->next = head;  // 连接原链表

delete dummy;  // 避免内存泄漏

std::unique_ptr<ListNode> dummy(new ListNode(0));  // 自动管理内存

ListNode* findKthFromEnd(ListNode* head, int k) {
    ListNode* dummy = new ListNode(0);
    dummy->next = head;
    ListNode *first = dummy, *second = dummy;
    // first先移动k+1步（包含dummy）
    for (int i = 1; i <= k + 1; i++) {
        first = first->next;
    }
    // 同时移动first和second
    while (first) {
        first = first->next;
        second = second->next;
    }
    ListNode* result = second->next;
    delete dummy;
    return result;
}

ListNode* reverseList(ListNode* head) {
    ListNode* dummy = new ListNode(0);  // 虚拟头节点
    dummy->next = head;
    ListNode* curr = head;
    while (curr && curr->next) {
        // 保存下一个节点
        ListNode* nextNode = curr->next;
        // 断开当前节点与下一个节点的连接
        curr->next = nextNode->next;
        // 将nextNode插入到虚拟头节点之后
        nextNode->next = dummy->next;
        dummy->next = nextNode;
    }
    ListNode* newHead = dummy->next;
    delete dummy;
    return newHead;
}