<leetcode>NO.2逆序单链表存储整数相加

最新推荐文章于 2022-03-02 21:47:23 发布

木棉花语

最新推荐文章于 2022-03-02 21:47:23 发布

阅读量286

点赞数

分类专栏： C/C++ 文章标签： leetcode

本文链接：https://blog.csdn.net/xuyuanwang19931014/article/details/90042399

版权

C/C++ 专栏收录该内容

223 篇文章 1 订阅

订阅专栏

本文介绍了一种使用逆序单链表表示非负整数的方法，并通过LeetCode上的NO.2问题讨论如何将两个这样的链表相加。通过代码实现，展示了解决方案，并分享了执行效率和内存消耗情况。尽管代码能有效解决大部分情况，但需要注意链表长度转换为整数时可能超出整数存储范围的问题。

摘要由CSDN通过智能技术生成

给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

//通过代码
#include <stdlib.h>
struct ListNode {
     int val;
     struct ListNode *next;
 };
struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
    unsigned int offset=0;//进位寄存
            struct ListNode*root_node=NULL;
            struct ListNode*tmp_node=NULL;
            int first_run=1;
            int bit_sum=0;
            /*step1:位相加阶段*/
            while(l1&&l2)
            {
                if(first_run)
                {
                    tmp_node=(struct ListNode*)malloc(sizeof(struct ListNode));
                    tmp_node->next=NULL;
                    root_node=tmp_node;
                    first_run=0;
                }
                else
                {
                    tmp_node->next=(struct ListNode*)malloc(sizeof(struct ListNode));
                    tmp_node->next->next=NULL;
                    tmp_node=tmp_node->next;
                }
                bit_sum=l1->val+l2->val+offset;
                offset=bit_sum/10;
                tmp_node->val=bit_sum%10;
                l1=l1->next;
                l2=l2->next;
            }
            /*step2:拷贝阶段*/
            while(l1)
            {
                tmp_node->next=(struct ListNode*)malloc(sizeof(struct ListNode));
                tmp_node->next->next=NULL;
                tmp_node=tmp_node->next;
                bit_sum=l1->val+offset;
                offset=bit_sum/10;
                tmp_node->val=bit_sum%10;
                l1=l1->next;
            }
            while(l2)
            {
                tmp_node->next=(struct ListNode*)malloc(sizeof(struct ListNode));
                tmp_node->next->next=NULL;
                tmp_node=tmp_node->next;
                bit_sum=l2->val+offset;
                offset=bit_sum/10;
                tmp_node->val=bit_sum%10;
                l2=l2->next;
            }
            if(!l1&&!l2&&offset)
            {
                tmp_node->next=(struct ListNode*)malloc(sizeof(struct ListNode));
                tmp_node->next->next=NULL;
                tmp_node=tmp_node->next;
                tmp_node->val=1;
            }
            return root_node;
}

//未通过的代码
struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
    //数据还原
    unsigned long long num1=0;
    unsigned long long num2=0;
    unsigned long long muti_base=1;
    while(l1||l2)
    {
        if(l1)
        {
            num1+=muti_base*l1->val;
            l1=l1->next;
        }
        if(l2)
        {
            num2+=muti_base*l2->val;
            l2=l2->next;
        }
        muti_base*=10;
    }
    //相加,转换成目标输出
    unsigned long long sum=num1+num2;

    struct ListNode*return_list=NULL ;
    struct ListNode*tmp=NULL;
    int first_run=1;
    while(sum||first_run)
    {
        if(first_run)
        {
            tmp =(struct ListNode*)malloc(sizeof(struct ListNode));
            tmp->next=NULL;
            return_list=tmp;
            first_run=0;
        }
        else
        {
            tmp->next=(struct ListNode*)malloc(sizeof(struct ListNode));
            tmp->next->next=NULL;
            tmp=tmp->next;
        }
        tmp->val=sum%10;
        sum=sum/10;
    }
    return return_list;
}

通过代码：

执行用时 : 28 ms, 在Add Two Numbers的C提交中击败了97.27% 的用户

内存消耗 : 9 MB, 在Add Two Numbers的C提交中击败了88.00% 的用户

未通过代码:链表长度转换成整数会超出整数存储最大值