链表相加(二)

简介: 链表相加(二)

这题拿到手上,我一直在考虑一个问题就是,能不能通过不预先遍历的方法去做。

呜呜,原谅我的无知,我想不出来。

那就只能先遍历一遍了,反正也是很不影响时间。

一看到这题,就冒出了两种解题方法,第一种是预先通过两个数组把两个链表中的数据保存下来,然后就变成了大数加法了,然后再把结果放到一个新的链表中。

还一种是补充短的链表,然后进行各个位相加,最后考虑进位。等等,好像不可以吧,如果这样的话,进位没办法解决了,毕竟是一个单链表。如果可行,最后还是要借助数组完成进位。

两种方法我都试一下吧!!!


解法1:开始我想着顺着存,这样就可以在统计长度的时候把数据放入数组中.最后发现进位难处理

 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    /**
     * 
     * @param head1 ListNode类 
     * @param head2 ListNode类 
     * @return ListNode类
     */
    int *arr1 =  new  int[1000002];        //用来保存结果
    int *arr2 =  new  int[1000002];
    ListNode* addInList(ListNode* head1, ListNode* head2) {
        // write code here
        //末尾对齐,遍历一遍
        int len1 = 0;
        int len2 = 0;
        ListNode *p1 = head1;
        ListNode *p2 = head2;
        while(p1 != nullptr)
        {
            p1 = p1->next;      
            len1++;
        }
        while(p2 != nullptr)
        {
            p2 = p2->next;
            len2++;
        }
        //将各个数位保存到数组中
        p1 = head1;
        for(int i=len1-1;i>=0;--i)
        {
            arr1[i] = p1->val;
            p1 = p1->next;
        }
        p2 = head2;
        for(int i=len2-1;i>=0;--i)
        {
            arr2[i] = p2->val;
            p2 = p2->next;
        }
        //各个位相加
        int len = len1 > len2 ? len1:len2;
        for(int i=0;i<len;++i)
        {
            arr1[i] = arr1[i] + arr2[i];
            arr1[i+1] =  arr1[i+1] +  arr1[i]/10;
            arr1[i] = arr1[i]%10;
        }
        ListNode *ans = nullptr;
        ListNode *p = nullptr;
        if(arr1[len] > 0)
        {
            ListNode *s = new ListNode(arr1[len]);
            s->next = nullptr;
            ans = s;
            p = s;
        }
        for(int k=len-1;k>=0;k--)
        {
            ListNode *s = new ListNode(arr1[k]);
            s->next = nullptr;
            if(ans == nullptr)
            {
                ans = s;
                p = s;
            }
            else
            {
                 p->next = s;
                 p = p->next;
            }
        }
        return ans;
    }
};

这里好像忘记释放数组里的内存了,一个好的习惯,还是建议释放掉


解法2:

 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    /**
     * 
     * @param head1 ListNode类 
     * @param head2 ListNode类 
     * @return ListNode类
     */
    ListNode* addInList(ListNode* head1, ListNode* head2) {
        // write code here
        //末尾对齐,遍历一遍
        int len1 = 0;
        int len2 = 0;
        ListNode *p1 = head1;
        ListNode *p2 = head2;
        while(p1 != nullptr)
        {
            p1 = p1->next;      
            len1++;
        }
        while(p2 != nullptr)
        {
            p2 = p2->next;
            len2++;
        }
        if(len1 > len2)
        {
            for(int i=0;i<len1-len2;++i)
            {
                ListNode *s = new ListNode(0);
                s->next = head2;
                head2 = s;
            }
        }
        if(len2 > len1)
        {
            for(int i=0;i<len2-len1;++i)
            {
                ListNode *s = new ListNode(0);
                s->next = head1;
                head1 = s;
            }
        }
        p1 = head1;
        p2 = head2;
        while(p1 != nullptr)
        {
            p1->val = p1->val + p2->val;
            p1 = p1->next;
            p2 = p2->next;
        }
        int len = len1 > len2 ? len1:len2;
        int *arr = new int[len+2];
        p1 = head1;
        for(int i=len-1;i>=0;--i)
        {
            arr[i] = p1->val;
//             arr[i+1] = arr[i+1] + arr[i]/10;
//             arr[i] = arr[i]%10;
            p1 = p1->next;
        }
        for(int i=0;i<len;++i)
        {
            arr[i+1] = arr[i+1] + arr[i]/10;
            arr[i] = arr[i]%10;
        }
        ListNode *ans = nullptr;
        ListNode *p = nullptr;
        if(arr[len] > 0)
        {
            ListNode *s = new ListNode(arr[len]);
            s->next = nullptr;
            ans = s;
            p = s;
        }
        for(int k=len-1;k>=0;--k)
        {
            ListNode *s = new ListNode(arr[k]);
            s->next = nullptr;
            if(ans == nullptr)
            {
                ans = s;
                p = s;
            }
            else
            {
                p->next = s;
                p = p->next;
            }
        }
        delete []arr;
        return ans;
    }
};
相关文章
|
Linux Docker 容器
.net Core WebApi发布到Docker并推送到阿里云容器服务
.net Core WebApi发布到Docker并推送到阿里云容器服务
1017 0
.net Core WebApi发布到Docker并推送到阿里云容器服务
|
存储 SQL 分布式计算
|
程序员 编译器 C语言
初识C语言——C语言基础知识(一)
初识C语言——C语言基础知识(一)
136 0
初识C语言——C语言基础知识(一)
|
缓存 开发工具 git
Git创建分支以及合并分支
在Git中,创建分支使用`git branch [branch_name]`,切换分支使用`git checkout [branch_name]`。修改文件后,通过`git add [file]`添加到暂存区,然后`git commit`提交到本地仓库。如果是新建分支的第一次推送,使用`git push origin [branch_name]`推送到远程仓库,之后可以简化为`git push`。合并分支时,使用`git merge [branch_name]`将指定分支的更改合并到当前分支。
492 2
Git创建分支以及合并分支
|
Prometheus 监控 Cloud Native
Prometheus结合Consul采集多个MySQL实例的监控指标
将 Prometheus 与 Consul 结合使用,实现对多个 MySQL 实例的自动发现与监控,不仅提高了监控的效率和准确性,也为管理动态扩缩容的数据库环境提供了强大的支持。通过细致配置每一部分,业务可以获得关键的性能指标和运行健康状况的即时反馈,进而优化资源配置,提高系统的稳定性和可用性。
552 3
|
12月前
|
缓存 IDE Java
SpringBoot入门(7)- 配置热部署devtools工具
SpringBoot入门(7)- 配置热部署devtools工具
1390 1
SpringBoot入门(7)- 配置热部署devtools工具
|
消息中间件 监控 Linux
RabbitMQ轻松入门:从零开始的部署与安装指南
RabbitMQ轻松入门:从零开始的部署与安装指南
348 0
RabbitMQ轻松入门:从零开始的部署与安装指南
|
Linux 开发工具 git
pip的常用命令和常见问题的解决
当使用pip命令安装Python包时,有时候可以通过使用镜像地址来加速下载速度或解决访问限制的问题。以下是一些常用的pip命令和常见的镜像地址:
1635 3
|
安全 Java Maven
Maven 镜像-阿里云
Maven 镜像-阿里云
3361 0
|
存储 数据采集 供应链
带你读《构建企业级好数据(Dataphin智能数据建设与治理白皮书)》——卷首语
带你读《构建企业级好数据(Dataphin智能数据建设与治理白皮书)》——卷首语
451 0