[Leetcode题解]2. 两数相加-链表遍历和重构

1. 审题leetcode 02 add-two-numbers​

我们先看一下题目，如下  ：

链表的从前往后为数字的低位到高位，模拟加法手算过程，从前往后遍历即可， 注意每个数字0-9,进位要处理好;

---

2. 解体思路

主要分4步来完成，增加一个头节点来处理后续的添加过程可能简单些;

• 处理l1 和 l2 共有元素的累加， 注意进位inc的累加;
• 处理多余的l1的内容;
• 处理多余的l2的内容;
• 处理最后剩余的进位;

---

3. 详细代码

3.1 直观的循环代码

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
 
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    var inc int
    head := ListNode{0, nil}
    lastNode := &head
    for ; l1 != nil && l2 != nil; l1, l2 = l1.Next, l2.Next {
        sum := l1.Val + l2.Val + inc
        if sum >= 10 {
            inc = 1
            sum -= 10
        } else {
            inc = 0
        }
        temp := ListNode{sum, nil}
        lastNode.Next = &temp
        lastNode = &temp
    }
    for ; l1 != nil; l1 = l1.Next {
        sum := l1.Val + inc
        if sum >= 10 {
            inc = 1
            sum -= 10
        } else {
            inc = 0
        }
        temp := ListNode{sum, nil}
        lastNode.Next = &temp
        lastNode = &temp
    }
    for ; l2 != nil; l2 = l2.Next {
        sum := l2.Val + inc
        if sum >= 10 {
            inc = 1
            sum -= 10
        } else {
            inc = 0
        }
        temp := ListNode{sum, nil}
        lastNode.Next = &temp
        lastNode = &temp
    }
    if inc != 0 {
        temp := ListNode{inc, nil}
        lastNode.Next = &temp
        lastNode = &temp
    }
    return head.Next
}

3.2 函数提炼重构

每个计算过程都包含取出两个数字，和进位一起求和，处理大于10的数字，继续下一轮;故抽取关键函数完成这个节点的处理

func addSumNode(n1 int, n2 int, inc int, lastNode *ListNode) (int, *ListNode) {
    sum := n1 + n2 + inc
    if sum >= 10 {
        inc = 1
        sum -= 10
    } else {
        inc = 0
    }
    temp := ListNode{sum, nil}
    lastNode.Next = &temp
    lastNode = &temp
    return inc, lastNode
}

func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    var inc int
    head := ListNode{0, nil}
    lastNode := &head
    for ; l1 != nil && l2 != nil; l1, l2 = l1.Next, l2.Next {
        inc, lastNode = addSumNode(l1.Val, l2.Val, inc, lastNode)
    }
    for ; l1 != nil; l1 = l1.Next {
        inc, lastNode = addSumNode(l1.Val, 0, inc, lastNode)
    }
    for ; l2 != nil; l2 = l2.Next {
        inc, lastNode = addSumNode(0, l2.Val, inc, lastNode)
    }
    if inc != 0 {
        inc, lastNode = addSumNode(0, 0, inc, lastNode)
    }
    return head.Next
}

---

4. 感悟总结

要重构代码不是特别难做的事情， 看到两次以上的重复就要有所警觉， 尝试提取公共部分，或者进一步优化代码整体结构， 你会发现代码是越来越容易懂，后续添加新需求也实现其来更加容易，更好复用，所以， 重构无小事， 重构也“不是难做的大事”，因为重构也就在点滴中; 小步快跑才是重构的精髓;

重构后代码看起来清爽很多， 55LOC => 32 LOC

运行时间对比：

执行用时：16 ms, 在所有 Go 提交中击败了39.76% 的用户
内存消耗：4.9 MB, 在所有 Go 提交中击败了21.00% 的用户

# 重构后
执行用时：12 ms, 在所有 Go 提交中击败了72.62% 的用户
内存消耗：4.9 MB, 在所有 Go 提交中击败了26.81% 的用户

永久地址： https://mp.weixin.qq.com/s/5OZx7i-oOGvDbxCWHPxi5A 已收录到公众号，欢迎关注 ：）