LeetCode题集 2.两数相加

题述

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

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

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

示例
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]

解释：342 + 465 = 807.

提示

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

思路

首先想到的是传统思路
将两个参数链表转化为数字相加得到结果后再塞回链表
随后被否决
因为根据提示 每个链表节点数在【1-100】内
100位ulong都hold不住。。。

那么 换一种小学生的计算方式
逐位相加进位法
想了一下 这个方式哪怕你1000位好像也完全ok
那么
题解首先需要一个标记是否进位的参数 carry
然后 这个方法最终输出一个listNode 为其头节点
但是按照计算流程的话 可以明确的仅有最后的一个节点
即需要在开始计算之前 先定义好头节点放在一边 等待整个计算结束后 返回头节点

所以

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int val=0, ListNode next=null) {
 *         this.val = val;
 *         this.next = next;
 *     }
 * }
 */
public class Solution {
    public ListNode AddTwoNumbers(ListNode l1, ListNode l2) {
        var carry = 0;
        var headNode = new ListNode(0);
        var curNode = headNode;

        //存在下一节点或进位上有值时则必须统计
        while(carry!=0 || l1!=null || l2!=null){ 
    
            // 计算当前位 val
            var curVal = (l1==null?0:l1.val) + (l2==null?0:l2.val) + carry;
            // 设置节点
            curNode.next = new ListNode(curVal%10);
            curNode = curNode.next;
            // 设置carry
            carry = curVal/10;
            // 将l1 l2 设置为下一个节点
            l1 = l1==null? null : l1.next;
            l2 = l2==null? null : l2.next;
        }
        return headNode.next;

    }
}

执行用时: 96 ms / beats 100% C# submitters
内存消耗: 27.6 MB / beats 60% C# submitters

emmm…
出乎我的意料 直接超越100%的C#提交者
这应该是比较直接能想到的解法才对

算了 分析一下这个代码

        var headNode = new ListNode(0);
        var curNode = headNode;

定义头节点 & 逻辑当前节点
headNode用于返回 ，而curNode用于迭代运算

那么 ，当参数 l1 和 l2开始逐位相加
在每次开始循环之前 先判断当前 l1 or l2 or carry 是否为空
当三者全部为空时判定为计算流程的结束
就应该返回那个头节点了
那么代码就变成

   while(carry!=0 || l1!=null || l2!=null){ 
    
           // todo curNode`s caculate
        }
        return headNode.next;

然后来看看循环内做的事

// 计算当前位 val
            var curVal = (l1==null?0:l1.val) + (l2==null?0:l2.val) + carry;
            // 设置节点
            curNode.next = new ListNode(curVal%10);
            curNode = curNode.next;
            // 设置carry
            carry = curVal/10;
            // 将l1 l2 设置为下一个节点
            l1 = l1==null? null : l1.next;
            l2 = l2==null? null : l2.next;

首先我们明确一点
在开始之前 headNode 和 curNode 都指向 头节点 head
然后开始第一次循环
将 l1 和 l2 的第一位 以及carry(此时为0) 都拿出来求和 理论上其值为 1<=curVal<=19 的任意数
但是curVal 应该做相应处理 即 curVal%10 存入即将生成的node
而十位决定carry值

那么
新节点为

new ListNode(curVal%10)

进位值为

carry = curVal/10;

然后来理解一下

curNode.next = new ListNode(curVal%10);

在执行这句代码前 curNode还指在 head 节点的位置
那么你的脑海中有没有一种 head 和后面的一个节点连起来的感觉
我们将后面的这个节点 先命名为 a 吧
然后

curNode = curNode.next;

将 curNode 指向了 a 节点的位置
对 , curNode不指向head了 它指向了 a
但是 headNode 依然指向 head
这就满足了一开始我们的需求

最后为下次计算循环做准备

// 将l1 l2 设置为下一个节点
            l1 = l1==null? null : l1.next;
            l2 = l2==null? null : l2.next;

当前 l1 or l2 非空时 将其指向其next节点 代入下次计算
试想一下 假设 l1 在本次计算时已经是最后一位了 那么它的next 是null
那么在下次循环计算中
while判断会因为 carry位 或者 l2 而进入循环 但使用到 l1 时 会被 0 值替换
l2 同理

如上 逐位完成了两个链表的全部计算 并返回结果链的头节点

题外话
listNode 的本质是一个class 即引用类型
可以理解为 headNode 将指针指向某一块内存 a
而curNode = headNode 实际上将其也指向 a
而在计算中 headNode 的指向始终不变
curNode 则在计算中逐渐后移直至结束

好了
就写到这里