[Go版]算法通关村第二关白银——链表加法

题目：链表相加

题目链接：LeetCode-445. 两数相加 II

思路分析

1. 先将两个链表反转，然后依次取出首位与当前进制位相加
2. 如果结果>=10，就将进制位+1，否则进制位=0
3. 将结果取余作为新节点的值，添加到新链表最后
4. 返回反转后的新链表

复杂度：时间复杂度: $O(n+Max(m,n))$、空间复杂度: $O(1)$

• 时间复杂度: $O(n+Max(m,n))$

  首先，reverseList 函数的时间复杂度为 $O(n)$，其中 n 是链表的长度。
  接下来，addTwoNumbers 函数中主要有两个循环。
  第一个循环用于将输入的两个链表翻转，因此时间复杂度为 $O(m)$ 和 $O(n)$，其中 m 和 n 分别是两个链表的长度。
  第二个循环用于遍历翻转后的两个链表并计算结果。由于两个链表都是翻转后的，长度最长为 max(m, n)，
  因此该循环的时间复杂度为 $O(max(m,n))$。
  综上所述，addTwoNumbers 函数的总时间复杂度为 $O(n+max(m,n))$，其中 n 是链表的长度，m 和 n 是两个链表的长度。

• 空间复杂度: $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)
}