[Swift]LeetCode2. 两数相加 | Add Two Numbers
2024-05-11 19:34:06
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9697862.html
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
You are given two non-empty linked lists representing two non-negative integers. 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.
You may assume the two numbers do not contain any leading zero, except the number 0 itself.
Example:
Input: (2 -> 4 -> 3) + (5 -> 6 -> 4) Output: 7 -> 0 -> 8 Explanation: 342 + 465 = 807.
给定两个非空链表来表示两个非负整数。位数按照逆序方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。
你可以假设除了数字 0 之外，这两个数字都不会以零开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807
64ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
14 var c1: ListNode? = l1
15 var c2: ListNode? = l2
16 if c1==nil
17 {return c2!}
18 if c2==nil
19 {return c1!}
20 var sentinel = ListNode(0)
21 var d: ListNode? = sentinel;
22 var sum:Int = 0
23 while (c1 != nil || c2 != nil) {
24 sum /= 10
25 if c1 != nil {
26 sum += c1!.val
27 c1 = c1!.next
28 }
29 if c2 != nil {
30 sum += c2!.val
31 c2 = c2!.next
32 }
33 d!.next = ListNode(sum % 10)
34 d = d!.next;
35 }
36
37 if sum / 10 == 1
38 {
39 d!.next = ListNode(1)
40 }
41 return sentinel.next
42 }
43 }64ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
14 var newList = ListNode(0);
15 var p = newList;
16 var p1 = l1;
17 var p2 = l2;
18 var div = 0;
19 while true {
20 let val1 = p1 == nil ? 0 : p1!.val;
21 let val2 = p2 == nil ? 0 : p2!.val;
22 let value = (val1 + val2 + div) % 10;
23 div = ((val1 + val2 + div) - value) / 10;
24 p.val = value;
25 if p1?.next == nil && p2?.next == nil && div == 0 {
26 break
27 } else {
28 p.next = ListNode(0);
29 p = p.next!;
30 if p1 != nil {
31 p1 = p1?.next;
32 }
33 if p2 != nil {
34 p2 = p2?.next;
35 }
36 }
37 }
38 return newList;
39 }
40 }68ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
14 guard l1 != nil, l2 != nil else { return nil }
15 guard l1 != nil else { return l2 }
16 guard l2 != nil else { return l1 }
17 guard var l1 = l1 as ListNode?, var l2 = l2 as ListNode? else { return nil }
18 var remainder: Int = 0
19 var newNode: ListNode?
20 var currentNode: ListNode?
21
22 let sum = l1.val + l2.val + remainder
23 let i: Int
24 if sum > 9 {
25 remainder = 1
26 i = sum - 10
27 } else {
28 remainder = 0
29 i = sum
30 }
31 if newNode == nil {
32 newNode = ListNode(i)
33 currentNode = newNode
34 } else {
35 currentNode!.next = ListNode(i)
36 currentNode = currentNode!.next
37 }
38
39 while l1.next != nil || l2.next != nil {
40 if l1.next != nil {
41 l1 = l1.next!
42 } else {
43 l1.val = 0
44 }
45 if l2.next != nil {
46 l2 = l2.next!
47 } else {
48 l2.val = 0
49 }
50 let sum = l1.val + l2.val + remainder
51 let i: Int
52 if sum > 9 {
53 remainder = 1
54 i = sum - 10
55 } else {
56 remainder = 0
57 i = sum
58 }
59 if newNode == nil {
60 newNode = ListNode(i)
61 currentNode = newNode
62 } else {
63 currentNode!.next = ListNode(i)
64 currentNode = currentNode!.next
65 }
66 }
67
68 if remainder == 1 {
69 if newNode == nil {
70 newNode = ListNode(remainder)
71 } else {
72 currentNode!.next = ListNode(remainder)
73 }
74 }
75
76 return newNode
77 }
78
79 func convertToString(_ l1: ListNode) -> String {
80 var node = l1
81 var str = "\(node.val)"
82 while node.next != nil {
83 node = node.next!
84 str = "\(node.val)" + str
85 }
86 return str
87 }
88 }72ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
14 var addition = 0
15
16 var tn1 = l1
17 var tn2 = l2
18 var lastRN = ListNode(0)
19 var ret: ListNode? = nil
20 while tn1 != nil || tn2 != nil || addition > 0 {
21 var rn = ListNode(0)
22
23 if tn1 != nil || tn2 != nil {
24 rn.val = ((tn1?.val ?? 0) + (tn2?.val ?? 0) + addition) % 10
25 addition = ((tn1?.val ?? 0) + (tn2?.val ?? 0) + addition) / 10
26 } else {
27 rn.val = addition
28 addition = 0
29 }
30
31 if tn1 === l1 || tn2 === l2 {
32 // first time
33 ret = rn
34 rn.next = nil
35 } else {
36 lastRN.next = rn
37 }
38 lastRN = rn
39 tn1 = tn1?.next
40 tn2 = tn2?.next
41 }
42 return ret
43 }
44 }76ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
14 var l1 = l1
15 var l2 = l2
16 var carry = 0
17 var sum = 0
18 var result = ListNode(0)
19 let head = result
20
21 while l1 != nil || l2 != nil || carry != 0{
22
23 let current = ListNode(0)
24
25 sum = (l1?.val ?? 0) + (l2?.val ?? 0) + carry
26 current.val = sum % 10
27 carry = sum >= 10 ? 1 : 0
28
29 result.next = current
30 result = current
31
32 l1 = l1?.next
33 l2 = l2?.next
34
35 }
36 return head.next
37 }
38 }80ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
14 var carryover = 0
15 var next:ListNode?
16 var result:ListNode?
17 var l1v = l1
18 var l2v = l2
19 while l1v != nil && l2v != nil
20 {
21 if next == nil
22 {
23 next = ListNode(0)
24 result = next
25 }
26 else
27 {
28 next?.next = ListNode(0)
29 next = next?.next!
30 }
31
32 var sum = l1v!.val + l2v!.val + carryover
33 carryover = 0
34 if sum >= 10
35 {
36 carryover = sum / 10
37 sum = sum % 10
38 }
39
40 next?.val = sum
41
42 l1v = l1v?.next
43 l2v = l2v?.next
44 }
45
46 if l1v != nil
47 {
48 while l1v != nil
49 {
50 next?.next = ListNode(0)
51 next = next?.next!
52
53 var sum = l1v!.val + carryover
54 carryover = 0
55 if sum >= 10
56 {
57 carryover = sum / 10
58 sum = sum % 10
59 }
60
61 next?.val = sum
62
63 l1v = l1v?.next
64 }
65 }
66
67 if l2v != nil
68 {
69 while l2v != nil
70 {
71 next?.next = ListNode(0)
72 next = next?.next!
73
74 var sum = l2v!.val + carryover
75 carryover = 0
76 if sum >= 10
77 {
78 carryover = sum / 10
79 sum = sum % 10
80 }
81
82 next?.val = sum
83
84 l2v = l2v?.next
85 }
86 }
87
88 if carryover > 0
89 {
90 next?.next = ListNode(carryover)
91 }
92
93 return result
94 }
95 }84ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
14 var returnList: ListNode?
15 var currentNode: ListNode?
16 var tempList: ListNode?
17
18 var currentL1 = l1
19 var currentL2 = l2
20
21 var carryForward: Int?
22
23 while currentL1 != nil || currentL2 != nil || carryForward != nil {
24 var combinedValue = carryForward != nil ? carryForward! : 0
25
26 carryForward = nil
27
28 if let cur1 = currentL1 {
29 combinedValue += cur1.val
30 }
31
32 if let cur2 = currentL2 {
33 combinedValue += cur2.val
34 }
35
36 if combinedValue/10 > 0 {
37 carryForward = 1
38 }
39
40 tempList = ListNode(combinedValue%10)
41 currentNode?.next = tempList
42
43 if returnList == nil {
44 returnList = tempList
45 }
46
47 currentNode = tempList
48
49 currentL1 = currentL1?.next
50 currentL2 = currentL2?.next
51 }
52
53 return returnList
54 }
55
56 func reverseLinkedList(_ ll: ListNode?) -> ListNode? {
57 var previousNode: ListNode?
58 var currentNode: ListNode?
59 var tempNode: ListNode?
60
61 previousNode = nil
62 currentNode = ll
63
64 while currentNode != nil {
65 tempNode = currentNode?.next
66 currentNode?.next = previousNode
67 previousNode = currentNode
68 currentNode = tempNode
69 }
70
71 return previousNode
72 }
73 }88ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
14 guard var l1 = l1, var l2 = l2 else {return nil}
15
16 var firstNode = ListNode((l1.val + l2.val) % 10)
17 var currentNode = firstNode
18 var listNode1 = l1.next
19 var listNode2 = l2.next
20 var addOne = (l1.val + l2.val) > 9
21 while listNode1 != nil || listNode2 != nil {
22 var sum = (listNode1?.val ?? 0) + (listNode2?.val ?? 0)
23 sum += addOne ? 1 : 0
24 let nextNode = ListNode(sum % 10)
25 currentNode.next = nextNode
26 currentNode = nextNode
27 addOne = sum > 9
28 listNode1 = listNode1?.next
29 listNode2 = listNode2?.next
30 }
31
32 if addOne { currentNode.next = ListNode(1) }
33
34 return firstNode
35 }
36 }转载于:https://www.cnblogs.com/strengthen/p/9697862.html
[Swift]LeetCode2. 两数相加 | Add Two Numbers相关推荐
- leetcode算法—两数相加 Add Two Numbers
关注微信公众号:CodingTechWork,一起学习进步. 题目 Add Two Numbers: You are given two non-empty linked lists represen ...
- LeetCode第二题：两数相加(Add Two Numbers）
LeetCode第二题:两数相加(python,java) You are given two non-empty linked lists representing two non-negative ...
- LeetCode2.两数相加
LeetCode2.两数相加 给出两个 非空 的链表用来表示两个非负的整数.其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字. 如果,我们将这两个数相加起来,则会 ...
- Leetcode-2 两数相加【c语言】
题目描述 给你两个 非空 的链表,表示两个非负的整数.它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字. 请你将两个数相加,并以相同形式返回一个表示和的链表. 你可以假设除了 ...
- leetcode-2 两数相加
给出两个 非空 的链表用来表示两个非负的整数.其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字. 如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和 ...
- leetcode2. 两数相加--每天刷一道leetcode系列！
来自:程序员面试 作者:reed,一个热爱技术的斜杠青年,程序员面试联合创始人 题目描述 给出两个 非空 的链表用来表示两个非负的整数.其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节 ...
- leetcode2 两数相加
题目描述: 给出两个 非空 的链表用来表示两个非负的整数.其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字. 如果,我们将这两个数相加起来,则会返回一个新的链表来 ...
- 简单算法题：leetcode-2 两数相加
算法撸一遍,从简单的开始. 做leetcode题目的时候,经常百度答案,但感觉大多不是我想要的,很多我不能理解.现在也做了一些算法题,哪些并不是很深奥,但需要一些技巧,简单的算法题更多的是经验值.这里 ...
- Leetcode--2. 两数相加
给出两个 非空 的链表用来表示两个非负的整数.其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字. 如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和 ...
最新文章
- （原）linux下caffe模型转tensorflow模型
- 当代最值得收藏的画家作品_欣赏当代知名画家谭日群——国画人物画书法作品欣赏...
- Vmware 中安装Unix
- 你最想要的圣诞礼物是什么?
- java 参数类型可变_java – 具有可变类型参数的通用
- ArcEngine中打开各种数据源（WorkSpace）的连接
- Linux 目录简要结构认识
- mysql报1665_mysql错误处理之ERROR 1665 (HY000)_MySQL
- 基于Ruby 安装 sass 安装出现的错误以及解决
- RabbitMQ连接超时问题
- 如何把图片分辨率调低？如何调整照片的分辨率？
- mysql碎片整理innodb_Innodb表碎片整理
- MIPI RFFE协议使用不完全指南（附上代码详解和参考资料）第一部分
- js删除json中指定的元素
- 使用虹软SDK进行视频人脸识别
- 斐讯（Phicomm）空气检测仪（悟空 M1）通过 EasyLink
- 【跨境必备】五分钟学会设定Facebook Chatbot
- 配置MRTG监控网络流量简单方法
- Fiddler4抓包工具的使用
- 微信开通批量检测软件的常见问题解答（入手必备）
热门文章
- quartus II Warning 好的时序是设计出来的，不是约束出来的
- Web服务器和应用程序服务器有什么区别
- Catterplots包，让你绘制不一样的图
- linux命令后缀-d和 都表示后台启动,Linux复习材料_关宇亮整理版.doc
- python统计excel中重复数据_EXCEL公式解读：统计不重复个数
- android获取状态栏截屏按钮状态,关于代码截屏带状态栏的问题
- java对象转json字符串日期格式_fastJSON字符串类型数据中的日期转换为Java bean的日期对象...
- C++知识点43——解引用运算符和箭头运算符的重载及智能指针类的实现
- html禁止f12键代码,网站禁用f12 禁止调试代码方法
- IDEA一直提示 错误: 找不到或无法加载主类