目录
题目:链表相加
思路分析
- 先将两个链表反转,然后依次取出首位与当前进制位相加
- 如果结果>=10,就将进制位+1,否则进制位=0
- 将结果取余作为新节点的值,添加到新链表最后
- 返回反转后的新链表
复杂度:时间复杂度: O ( n + M a x ( m , n ) ) O(n+Max(m,n)) O(n+Max(m,n))、空间复杂度: O ( 1 ) O(1) O(1)
- 时间复杂度:
O
(
n
+
M
a
x
(
m
,
n
)
)
O(n+Max(m,n))
O(n+Max(m,n))
首先,reverseList 函数的时间复杂度为 O ( n ) O(n) O(n),其中 n 是链表的长度。
接下来,addTwoNumbers 函数中主要有两个循环。
第一个循环用于将输入的两个链表翻转,因此时间复杂度为 O ( m ) O(m) O(m) 和 O ( n ) O(n) O(n),其中 m 和 n 分别是两个链表的长度。
第二个循环用于遍历翻转后的两个链表并计算结果。由于两个链表都是翻转后的,长度最长为 max(m, n),
因此该循环的时间复杂度为 O ( m a x ( m , n ) ) O(max(m, n)) O(max(m,n))。
综上所述,addTwoNumbers 函数的总时间复杂度为 O ( n + m a x ( m , n ) ) O(n + max(m, n)) O(n+max(m,n)),其中 n 是链表的长度,m 和 n 是两个链表的长度。 - 空间复杂度:
O
(
1
)
O(1)
O(1)
该函数使用了常量级别的额外空间来存储变量和指针,没有使用与输入规模成比例的额外数据结构。
因此,空间复杂度为 O ( 1 ) O(1) O(1)。
注意,虽然在 addTwoNumbers 函数中调用了 reverseList 函数,但是 reverseList 函数的空间复杂度在这里并不会影响 addTwoNumbers 函数的空间复杂度,因为 reverseList 函数的递归过程会被完全展开,并且只有常数级别的变量在堆栈中。
Go代码
type ListNode struct {
Val int
Next *ListNode
}
func reverseList(head *ListNode) *ListNode {
if head == nil || head.Next == nil {
return head
}
tmp := head
newList := reverseList(tmp.Next)
tmp.Next.Next = tmp
tmp.Next = nil
return newList
}
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
if l1 == nil {
return l2
}
if l2 == nil {
return l1
}
dummyHead := &ListNode{}
tmp := dummyHead
l1, l2 = reverseList(l1), reverseList(l2)
site_shi, val, val1, val2 := 0, 0, 0, 0
for l1 != nil || l2 != nil || site_shi != 0 {
if l1 != nil {
val1 = l1.Val
l1 = l1.Next
}
if l2 != nil {
val2 = l2.Val
l2 = l2.Next
}
val = val1 + val2 + site_shi
if val >= 10 {
val = val % 10
site_shi = 1
} else {
site_shi = 0
}
tmp.Next = &ListNode{Val:val}
tmp = tmp.Next
val1, val2 = 0, 0
}
return reverseList(dummyHead.Next)
}