LeetCode AddTwoNumbers问题：链表传递至函数的类型错误排查

核心问题梳理 #

你的代码存在多个关键问题，导致类型不匹配、未定义行为等错误：

• 未初始化指针：main中Num_List *list, *list2;仅声明指针，未分配内存，直接调用成员函数会触发崩溃。
• 全局head变量冲突：全局的ListNode* head;会被所有Num_List实例共享，导致多个链表数据混乱。
• 继承关系误用：Num_List继承ListNode是错误的设计——ListNode是链表节点，Num_List是链表管理类，应该用组合关系（将head作为类成员）而非继承。
• 参数传递错误：(ListNode*)list->val将int类型强制转为指针，完全不符合函数参数要求，应该传递链表的头节点指针。
• 返回值错误：LeetCode的addTwoNumbers要求返回结果链表的头指针，你的代码返回int类型，属于非法类型转换。
• 逻辑bug：addTwoNumbers中dig2的取值错误，误将l1的val赋值给dig2。

修正后的完整代码 #

1. 头文件List_Node.h

#pragma once
#ifndef LIST_NODE_H
#define LIST_NODE_H

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

class Num_List {
private:
    ListNode* head; // 将head改为类私有成员，避免全局冲突
public:
    Num_List() : head(nullptr) {} // 初始化成员head
    ~Num_List();

    void appendNode(int);
    void insertNode(int);
    void deleteNode(int);
    void displayList() const;
    ListNode* addTwoNumbers(ListNode*, ListNode*); // 修改返回值为ListNode*
    ListNode* getHead() const { return head; } // 添加获取头节点的方法
};

#endif

2. 实现文件List_Node.cpp

#include "List_Node.h"
#include <iostream>

using namespace std;

Num_List::~Num_List() {
    ListNode* nodePtr = head;
    while (nodePtr != nullptr) {
        ListNode* nextNode = nodePtr->next;
        delete nodePtr;
        nodePtr = nextNode;
    }
}

void Num_List::appendNode(int num) {
    ListNode* newNode = new ListNode(num);
    if (!head) {
        head = newNode;
    } else {
        ListNode* nodePtr = head;
        while (nodePtr->next) {
            nodePtr = nodePtr->next;
        }
        nodePtr->next = newNode;
    }
}

void Num_List::insertNode(int num) {
    ListNode* newNode = new ListNode(num);
    if (!head) {
        head = newNode;
    } else {
        ListNode* nodePtr = head;
        ListNode* previousNode = nullptr;
        while (nodePtr != nullptr && nodePtr->val < num) {
            previousNode = nodePtr;
            nodePtr = nodePtr->next;
        }
        if (previousNode == nullptr) {
            head = newNode;
            newNode->next = nodePtr;
        } else {
            previousNode->next = newNode;
            newNode->next = nodePtr;
        }
    }
}

void Num_List::deleteNode(int num) {
    if (!head) return;
    if (head->val == num) {
        ListNode* temp = head;
        head = head->next;
        delete temp;
    } else {
        ListNode* nodePtr = head;
        ListNode* previousNode = nullptr;
        while (nodePtr != nullptr && nodePtr->val != num) {
            previousNode = nodePtr;
            nodePtr = nodePtr->next;
        }
        if (nodePtr) {
            previousNode->next = nodePtr->next;
            delete nodePtr;
        }
    }
}

void Num_List::displayList() const {
    ListNode* nodePtr = head;
    while (nodePtr) {
        cout << nodePtr->val << endl;
        nodePtr = nodePtr->next;
    }
}

ListNode* Num_List::addTwoNumbers(ListNode* l1, ListNode* l2) {
    ListNode* dummyHead = new ListNode(0);
    ListNode* tail = dummyHead;
    int carry = 0;
    while (l1 != nullptr || l2 != nullptr || carry != 0) {
        int dig1 = (l1 != nullptr) ? l1->val : 0;
        int dig2 = (l2 != nullptr) ? l2->val : 0; // 修正dig2的取值
        int sum = dig1 + dig2 + carry;
        int digit = sum % 10;
        carry = sum / 10;
        tail->next = new ListNode(digit);
        tail = tail->next;
        if (l1) l1 = l1->next;
        if (l2) l2 = l2->next;
    }
    ListNode* result = dummyHead->next;
    delete dummyHead;
    return result;
}

3. 主函数main.cpp

#include <iostream>
#include "List_Node.h"

using namespace std;

// 辅助函数：打印结果链表
void printResult(ListNode* head) {
    cout << "Result List" << endl;
    cout << "--------" << endl;
    while (head) {
        cout << head->val << endl;
        head = head->next;
    }
}

int main() {
    // 分配内存初始化Num_List实例
    Num_List* list = new Num_List();
    Num_List* list2 = new Num_List();

    cout << "List 1" << endl;
    cout << "--------" << endl;
    list->appendNode(1);
    list->appendNode(2);
    list->appendNode(3);
    list->displayList();

    cout << "List 2" << endl;
    cout << "--------" << endl;
    list2->appendNode(3);
    list2->appendNode(2);
    list2->appendNode(1);
    list2->displayList();

    // 传递两个链表的头节点给addTwoNumbers
    ListNode* result = list->addTwoNumbers(list->getHead(), list2->getHead());
    printResult(result);

    // 释放资源
    delete list;
    delete list2;
    // 释放结果链表
    ListNode* temp;
    while (result) {
        temp = result;
        result = result->next;
        delete temp;
    }

    return 0;
}

关键修正说明 #

1. 移除全局head：将head改为Num_List的私有成员，每个链表实例拥有独立的头节点，避免数据冲突。
2. 修正继承关系：取消Num_List对ListNode的继承，改为组合管理，符合链表类的设计逻辑。
3. 初始化指针：main中用new Num_List()创建实例，避免未初始化指针的非法访问。
4. 正确传递参数：通过getHead()方法获取链表头节点，作为addTwoNumbers的参数，解决类型不匹配问题。
5. 修正返回值与逻辑：将addTwoNumbers返回值改为ListNode*，修复dig2的取值错误，符合LeetCode题目要求。
6. 资源释放：添加结果链表的内存释放，避免内存泄漏。

内容的提问来源于stack exchange，提问作者Henry Lj