LeetCode： 2. 两数相加

dreamer'~

已于 2022-08-01 16:58:55 修改

阅读量240

点赞数

分类专栏： # LeetCode 文章标签： leetcode 链表算法

于 2022-08-01 16:57:22 首次发布

本文链接：https://blog.csdn.net/qq_37102984/article/details/126104262

版权

LeetCode 专栏收录该内容

176 篇文章 3 订阅

订阅专栏

2. 两数相加

难度中等8421

给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
提示：

每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零

思路：利用字符串按位相加，注意考虑进位及新链表的节点的处理。具体见代码注释~

整体思路优化精简前，
整体思路优化精简ing...
整体思路优化精简后。

时间复杂度：O(max(m,n))，其中 m 和 n 分别为两个链表的长度。我们要遍历两个链表的全部位置，而处理每个位置只需要 O(1) 的时间。

空间复杂度： O(1)，注意返回值不计入空间复杂度。

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
// 1、整体思路优化精简前：
// func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
//     head := &ListNode{}
//     carry := 0  // 进位值，一般为1
//     cur, cur1, cur2 := head, l1, l2
    
//     for cur1 != nil || cur2 != nil { // 注意：条件为 ||
//         sum := 0
//         if cur1 != nil && cur2 != nil {
//             sum = cur1.Val + cur2.Val + carry
//             cur.Next = &ListNode{
//                 Val: sum%10, // 取模 + 上一轮进位
//                 Next:nil,
//             }

//             cur, cur1, cur2 = cur.Next, cur1.Next, cur2.Next
//         } else if cur1 != nil {
//             sum = cur1.Val + carry
//             cur.Next = &ListNode{
//                 Val: sum%10, // 取模 + 上一轮进位
//                 Next:nil,
//             }

//             cur, cur1 = cur.Next, cur1.Next
//         } else if cur2 != nil {
//             sum = cur2.Val + carry
//             cur.Next = &ListNode{
//                 Val: sum%10, // 取模 + 上一轮进位
//                 Next:nil,
//             }

//             cur, cur2 = cur.Next, cur2.Next
//         }

//         // 单独处理下一轮的进位
//         if sum >= 10 {
//             carry = 1
//         } else {
//             carry = 0
//         }
//     }

//     // 当l1和l2都遍历完后，处理最后的一次进位。例如：99+9=108，这里需要处理百位最后的1
//     if carry != 0 {
//         cur.Next = &ListNode{
//             Val: carry,
//             Next: nil,
//         }
//     }

//     return head.Next
// }

// 2、整体思路优化精简ing：
// func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
//     head := &ListNode{}
//     carry := 0  // 进位值，一般为1
//     cur, cur1, cur2 := head, l1, l2
    
//     for cur1 != nil || cur2 != nil { // 注意：条件为 ||
//         sum := 0
//         if cur1 != nil && cur2 != nil {
//             sum = cur1.Val + cur2.Val + carry
//             cur1, cur2 = cur1.Next, cur2.Next
//         } else if cur1 != nil {
//             sum = cur1.Val + carry
//             cur1 = cur1.Next
//         } else if cur2 != nil {
//             sum = cur2.Val + carry
//             cur2 = cur2.Next
//         }

//         // 单独处理新链表的节点
//         cur.Next = &ListNode{
//                 Val: sum%10, // 取模 + 上一轮进位
//                 Next:nil,
//             }
//         cur = cur.Next

//         // 单独处理下一轮的进位
//         if sum >= 10 {
//             carry = 1
//         } else {
//             carry = 0
//         }
//     }

//     // 当l1和l2都遍历完后，处理最后的一次进位。例如：99+9=108，这里需要单独处理百位最后的1
//     if carry != 0 {
//         cur.Next = &ListNode{
//             Val: carry,
//             Next: nil,
//         }
//     }

//     return head.Next
// }

// 3、整体思路优化精简后：
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    head := &ListNode{}
    cur := head
    carry := 0  // 进位值，一般为1
    
    for l1 != nil || l2 != nil { // 注意：条件为 ||
        sum, val1, val2 := 0, 0, 0
        if l1 != nil {
            val1 = l1.Val
            l1 = l1.Next
        }
        
        if l2 != nil {
            val2 = l2.Val
            l2 = l2.Next
        }

        sum = val1 + val2 + carry
        sum, carry = sum%10, sum/10 // 单独处理下一轮的carry进位

        // 单独处理新链表的节点
        cur.Next = &ListNode{
            Val: sum,
            Next:nil,
        }
        cur = cur.Next   
    }

    // 当l1和l2都遍历完后，处理最后的一次进位。例如：99+9=108，这里需要单独处理百位最后的1
    if carry != 0 {
        cur.Next = &ListNode{
            Val: carry,
            Next: nil,
        }
    }

    return head.Next
}