Question

我目前正在处理链接列表的leetcode问题，这让我难以理解。问题陈述：

您将获得两个非空链表，表示两个非负整数。数字以相反的顺序存储，每个节点包含一个数字。添加两个数字并将其作为链接列表返回。您可以假设这两个数字不包含任何前导零，除了数字0本身。

示例：

输入：

  [2,4,3]
  [5,6,4]

预期输出：

[7,0,8]

我的输出：

[7]

我的返回列表只打印最后一个值[7]。

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

/*Used to free a linked list in C*/

   void freeLinkedList(struct ListNode * aptr)
        {
            while( aptr != 0)
            {
                struct ListNode * temp = aptr;
                aptr = aptr->next;
                free(temp);
            }
        }

我的功能：

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) 
{
    struct ListNode * NewNode = 0;
    struct ListNode * curr;
    struct ListNode * L1, *L2;
    L1 = l1;
    L2 = l2;
    int carry = 0;
    while (L1 != 0 | L2 != 0)
    {
        int x = (L1 != 0) ? L1->val: 0;
        int y = (L2 != 0) ? L2->val : 0;
        int sum = x + y + carry;
        carry = sum / 10;
        struct ListNode * tempnode = (struct ListNode *)malloc(sizeof(struct ListNode));
        tempnode->val = (sum % 10);
        tempnode->next = 0;


        if(NewNode == 0)
        {
            NewNode = tempnode;
            curr = NewNode->next;
        }else{

            curr = tempnode;
            curr = curr->next;
        }

        if(L1)
        L1 = L1->next;

        if(L2)
        L2 = L2->next;
    }

    if(carry > 0)
    {
        struct ListNode * tempnode2 = (struct ListNode *)malloc(sizeof(struct ListNode));
        tempnode2->val = carry;
        tempnode2->next = 0;
        NewNode->next = tempnode2;
    }

    struct ListNode * aptr = NewNode;


    return aptr;
}

一直在研究这个问题几个小时，但仍然不知怎的。有人能指出我正确的方向吗？请不要直接回答。

更新：在Tudatn建议之后我能够正常工作：

更新代码：

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2)
{
    struct ListNode * NewNode = 0;
    struct ListNode * curr = 0;
    struct ListNode * L1, *L2;
    L1 = l1;
    L2 = l2;
    int carry = 0;
    while (L1 != 0 | L2 != 0)
    {
        int x = (L1 != 0) ? L1->val : 0;
        int y = (L2 != 0) ? L2->val : 0;
        int sum = x + y + carry;
        carry = sum / 10;

        struct ListNode * tempnode = (struct ListNode *)malloc(sizeof(struct ListNode));
        tempnode->val = (sum % 10);
        tempnode->next = 0;


        if (NewNode == 0)
        {
            NewNode = tempnode;
            curr = NewNode;
        }
        else 
        {
            curr->next = tempnode;
            curr = curr->next;
        }

        if (L1)
            L1 = L1->next;

        if (L2)
            L2 = L2->next;
    }

    if (carry > 0)
    {
        struct ListNode * tempnode2 = (struct ListNode *)malloc(sizeof(struct ListNode));
        tempnode2->val = carry;
        tempnode2->next = 0;
        curr->next = tempnode2;
        curr = curr->next;
    }

    return NewNode;
}

由于

Answer 1

我想问题的挑战是如何在仍然向列表添加新节点的同时维护返回列表头指针。一个技巧是最初将返回列表设置为NULL并在添加新节点之前进行检查，例如：

if (result == NULL) {
    result = newNode;
    temp   = result;
} else {
      temp->next = newNode;
      temp = temp->next;
}

如果你想更多地使用这种类型的问题（即链表），更难的挑战可以是使用递归（使用支持函数）。玩得开心。

LinkedList反向添加

1 个答案: