You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4) Output: 7 -> 0 -> 8

首先使用链表实现等长无进位的求和,即实现 (1 —> 2 -> 3) + (1 -> 2 -> 3)=(2 -> 3 -> 6)

 #include <iostream>

 using namespace std;

 struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
}; class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { int val1 = , val2 = ; ListNode *l = NULL;
ListNode *l_end = NULL;
ListNode *l_new = NULL; val1 = l1->val;
val2 = l2->val;
l1 = l1->next;
l2 = l2->next;
l_new = (ListNode *)new ListNode((val1 + val2) % );
l_new->next = NULL;
l = l_new;
l_end = l;
while (l1 != NULL || l2 != NULL){ val1 = l1->val;
val2 = l2->val;
l1 = l1->next;
l2 = l2->next; l_new = (ListNode *)new ListNode((val1 + val2)%);
l_new->next = NULL; l_end->next = l_new;
l_end = l_new;
} return l; }
}; int main()
{
ListNode *l1, *l2;
ListNode *l;
l1 = (ListNode *)new ListNode();
l2 = (ListNode *)new ListNode();
l1->next = (ListNode *)new ListNode();
l2->next = (ListNode *)new ListNode();
l1->next->next = (ListNode *)new ListNode();
l2->next->next = (ListNode *)new ListNode();
Solution s;
l = s.addTwoNumbers(l1, l2);
while (l != NULL){
cout << l->val << endl;
l = l->next;
}
while ();
}

运行结果:

然后实现不等长无进位的求和,即实现 (1 —> 2 -> 3) + (1)=(2 -> 2 -> 3)

 #include <iostream>

 using namespace std;

 struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
}; class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { int val1 = , val2 = ; ListNode *l = NULL;
ListNode *l_end = NULL;
ListNode *l_new = NULL; val1 = l1->val;
val2 = l2->val;
l1 = l1->next;
l2 = l2->next;
l_new = (ListNode *)new ListNode((val1 + val2) % );
l_new->next = NULL;
l = l_new;
l_end = l;
while (l1 != NULL || l2 != NULL){
if (l1 == NULL){
val2 = l2->val;
l2 = l2->next;
val1 = ;
}
else if (l2 == NULL){
val1 = l1->val;
l1 = l1->next;
val2 = ;
}
else{
val1 = l1->val;
val2 = l2->val;
l1 = l1->next;
l2 = l2->next;
} l_new = (ListNode *)new ListNode((val1 + val2)%);
l_new->next = NULL; l_end->next = l_new;
l_end = l_new;
} return l; }
}; int main()
{
ListNode *l1, *l2;
ListNode *l;
l1 = (ListNode *)new ListNode();
l2 = (ListNode *)new ListNode();
l1->next = (ListNode *)new ListNode();
//l2->next = (ListNode *)new ListNode(2);
l1->next->next = (ListNode *)new ListNode();
//l2->next->next = (ListNode *)new ListNode(3);
Solution s;
l = s.addTwoNumbers(l1, l2);
while (l != NULL){
cout << l->val << endl;
l = l->next;
}
while ();
}

运行结果:

最后实现不等长有进位的求和,即实现题目要求(注意最后一位有进位的情况)

 #include <iostream>

 using namespace std;

 struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
}; class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { int val1 = , val2 = , carry = ; ListNode *l = NULL;
ListNode *l_end = NULL;
ListNode *l_new = NULL; val1 = l1->val;
val2 = l2->val;
l1 = l1->next;
l2 = l2->next;
l_new = (ListNode *)new ListNode((val1 + val2 + carry) % );
l_new->next = NULL;
l = l_new;
carry = (val1 + val2 + carry) / ;
l_end = l;
while (l1 != NULL || l2 != NULL){
if (l1 == NULL){
val2 = l2->val;
l2 = l2->next;
val1 = ;
}
else if (l2 == NULL){
val1 = l1->val;
l1 = l1->next;
val2 = ;
}
else{
val1 = l1->val;
val2 = l2->val;
l1 = l1->next;
l2 = l2->next;
} l_new = (ListNode *)new ListNode((val1 + val2 + carry)%);
l_new->next = NULL;
carry = (val1 + val2 + carry) / ; l_end->next = l_new;
l_end = l_new;
}
if (carry != ){
l_new = (ListNode *)new ListNode(carry);
l_new->next = NULL;
l_end->next = l_new;
l_end = l_new;
}
return l; }
}; int main()
{
ListNode *l1, *l2;
ListNode *l;
l1 = (ListNode *)new ListNode();
l2 = (ListNode *)new ListNode();
l1->next = (ListNode *)new ListNode();
l2->next = (ListNode *)new ListNode();
l1->next->next = (ListNode *)new ListNode();
l2->next->next = (ListNode *)new ListNode();
Solution s;
l = s.addTwoNumbers(l1, l2);
while (l != NULL){
cout << l->val << endl;
l = l->next;
}
while ();
}

运行结果:

因为是一边学C++,一边刷leetcode,所以有什么问题,十分感谢您能指点。

leetcode刷题: 002 Add Two Numbers的更多相关文章

  1. LeetCode刷题系列——Add Two Numbers

    题目链接 这个题目很简单,归并而已,好久没练编程,居然忘了在使用自定义类型前,要进行初始化(new操作). class ListNode{ int val; ListNode next; ListNo ...

  2. LeetCode第二题:Add Two Numbers

    You are given two non-empty linked lists representing two non-negative integers. The digits are stor ...

  3. 刷题2. Add Two Numbers

    一.题目要求 You are given two non-empty linked lists representing two non-negative integers. The digits a ...

  4. LeetCode刷题笔录Add Binary

    Given two binary strings, return their sum (also a binary string). For example, a = "11" b ...

  5. C#LeetCode刷题-数学

    数学篇 # 题名 刷题 通过率 难度 2 两数相加   29.0% 中等 7 反转整数 C#LeetCode刷题之#7-反转整数(Reverse Integer) 28.6% 简单 8 字符串转整数 ...

  6. LeetCode刷题指南(字符串)

    作者:CYC2018 文章链接:https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Leetcode+%E9%A2%98%E8%A7% ...

  7. LeetCode刷题总结-数组篇(上)

    数组是算法中最常用的一种数据结构,也是面试中最常考的考点.在LeetCode题库中,标记为数组类型的习题到目前为止,已累计到了202题.然而,这202道习题并不是每道题只标记为数组一个考点,大部分习题 ...

  8. LeetCode刷题总结-数组篇(中)

    本文接着上一篇文章<LeetCode刷题总结-数组篇(上)>,继续讲第二个常考问题:矩阵问题. 矩阵也可以称为二维数组.在LeetCode相关习题中,作者总结发现主要考点有:矩阵元素的遍历 ...

  9. LeetCode刷题总结-数组篇(下)

    本期讲O(n)类型问题,共14题.3道简单题,9道中等题,2道困难题.数组篇共归纳总结了50题,本篇是数组篇的最后一篇.其他三个篇章可参考: LeetCode刷题总结-数组篇(上),子数组问题(共17 ...

  10. LeetCode刷题总结-树篇(上)

          引子:刷题的过程可能是枯燥的,但程序员们的日常确不乏趣味.分享一则LeetCode上名为<打家劫舍 |||>题目的评论: 如有兴趣可以从此题为起点,去LeetCode开启刷题之 ...

随机推荐

  1. nl2br() 函数

    nl2br() 函数在字符串中的每个新行 (\n) 之前插入 HTML 换行符 (<br />).经常用于在线编辑的内容,以便显示. 用法:nl2br(string) 参数 描述 stri ...

  2. Smart210学习记录----nand flash驱动

    [详解]如何编写Linux下Nand Flash驱动  :http://www.cnblogs.com/linux-rookie/articles/3016990.html 当读写文件请求到来的时候, ...

  3. F - To the Max

    Given a two-dimensional array of positive and negative integers, a sub-rectangle is any contiguous s ...

  4. C语言共用体内存计算

    其实union(共用体)的各个成员是以同一个地址开始存放的,每一个时刻只可以存储一个成员,这样就要求它在分配内存单元时候要满足两点: 1.一般而言,共用体类型实际占用存储空间为其最长的成员所占的存储空 ...

  5. tf.slice可以用于矩阵也就是图片的切割

    第一个向量表示切割的起点,第二个向量表示矩形框的大小,-1表示取该元素的最大值

  6. 惩罚因子(penalty term)与损失函数(loss function)

    penalty term 和 loss function 看起来很相似,但其实二者完全不同. 惩罚因子: penalty term的作用是把受限优化问题转化为非受限优化问题. 比如我们要优化: min ...

  7. [hdu 4307]Matrix

    真是一道很好的题目喵~ 一看题面真是无语了……很直接.很暴力.很恶心.说实话,除了 straight forward 我脑子里就没想过别的 上网看了一下居然是最小割,脑子里面一下子就清醒了,N< ...

  8. 组合模式(Composite Pattern)

    组合模式主要用来处理一类具有“容器特征”的对象——即它们在充当对象的同时,又可以作为容器包含其他多个对象. 组合模式实现的最关键的地方是——简单对象和复合对象必须实现相同的接口.这就是组合模式能够将组 ...

  9. redis 集群环境搭建-redis集群管理

    集群架构 (1)所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽. (2)节点的fail是通过集群中超过半数的节点检测失效时才生效. (3)客户端与redi ...

  10. 极值问题(acms)

    [问题描述] 已知m.n为整数,且满足下列两个条件: ① m.n∈{1,2,…,k},即1≤m,n≤k,(1≤k≤109). ②(n2-m*n-m2)2=1 你的任务是:编程输入正整数k,求一组满足上 ...