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

1. 审题leetcode 02 add-two-numbers

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

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

2. 解体思路

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

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

3. 详细代码

3.1 直观的循环代码

 1 /**

 2  * Definition for singly-linked list.

 3  * type ListNode struct {

 4  *     Val int

 5  *     Next *ListNode

 6  * }

 7  */

 8

 9 func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {

10     var inc int

11     head := ListNode{0, nil}

12     lastNode := &head

13     for ; l1 != nil && l2 != nil; l1, l2 = l1.Next, l2.Next {

14         sum := l1.Val + l2.Val + inc

15         if sum >= 10 {

16             inc = 1

17             sum -= 10

18         } else {

19             inc = 0

20         }

21         temp := ListNode{sum, nil}

22         lastNode.Next = &temp

23         lastNode = &temp

24     }

25     for ; l1 != nil; l1 = l1.Next {

26         sum := l1.Val + inc

27         if sum >= 10 {

28             inc = 1

29             sum -= 10

30         } else {

31             inc = 0

32         }

33         temp := ListNode{sum, nil}

34         lastNode.Next = &temp

35         lastNode = &temp

36     }

37     for ; l2 != nil; l2 = l2.Next {

38         sum := l2.Val + inc

39         if sum >= 10 {

40             inc = 1

41             sum -= 10

42         } else {

43             inc = 0

44         }

45         temp := ListNode{sum, nil}

46         lastNode.Next = &temp

47         lastNode = &temp

48     }

49     if inc != 0 {

50         temp := ListNode{inc, nil}

51         lastNode.Next = &temp

52         lastNode = &temp

53     }

54     return head.Next

55 }

3.2 函数提炼重构

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

 1 func addSumNode(n1 int, n2 int, inc int, lastNode *ListNode) (int, *ListNode) {

 2     sum := n1 + n2 + inc

 3     if sum >= 10 {

 4         inc = 1

 5         sum -= 10

 6     } else {

 7         inc = 0

 8     }

 9     temp := ListNode{sum, nil}

10     lastNode.Next = &temp

11     lastNode = &temp

12     return inc, lastNode

13 }

14

15 func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {

16     var inc int

17     head := ListNode{0, nil}

18     lastNode := &head

19     for ; l1 != nil && l2 != nil; l1, l2 = l1.Next, l2.Next {

20         inc, lastNode = addSumNode(l1.Val, l2.Val, inc, lastNode)

21     }

22     for ; l1 != nil; l1 = l1.Next {

23         inc, lastNode = addSumNode(l1.Val, 0, inc, lastNode)

24     }

25     for ; l2 != nil; l2 = l2.Next {

26         inc, lastNode = addSumNode(0, l2.Val, inc, lastNode)

27     }

28     if inc != 0 {

29         inc, lastNode = addSumNode(0, 0, inc, lastNode)

30     }

31     return head.Next

32 }

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 已收录到公众号，欢迎关注：）

巴特西

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

1. 审题leetcode 02 add-two-numbers

2. 解体思路

3. 详细代码

3.1 直观的循环代码

3.2 函数提炼重构

4. 感悟总结

最新文章

热门文章

巴特西

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

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

2. 解体思路

3. 详细代码

3.1 直观的循环代码

3.2 函数提炼重构

4. 感悟总结

最新文章

热门文章

1. 审题leetcode 02 add-two-numbers