力扣(LeetCode) 2.两数相加 java

2.两数相加(中等)

题目如下:

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

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

你可以假设除了数字 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
• 题目数据保证列表表示的数字不含前导零

方法一：

第一个方法永远是暴力，想怎么来就怎么来。思路是这样的，把传进来的两个链表里的数都分别拼成字符串，因为长度是1到100，所以是大数，那么就通过BigInteger来解决，解决完再塞到新的链表里即可。这是我刚看到这道题的思路，所以效率什么的也没考虑，最终运行时间竟然20ms，这就是爽的代价…

还有个注意点就是注释代码其实就是ListNode类，你就可以知道它的构造

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
import java.math.BigInteger;

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //注意StringBuffer初始化填个int参数 这个int是容量 这里被坑了 没注意
        StringBuffer sb1 = new StringBuffer("" + l1.val);
        while(l1.next != null){
            //通过next来遍历这个链表
            l1 = l1.next;
            sb1.append(l1.val);
        }
        //因为链表里的数是逆序的，通过BigInteger来相加 肯定先搞回正序
        sb1.reverse();
        //与上面一样
        StringBuffer sb2 = new StringBuffer("" + l2.val);
        while(l2.next != null){
            l2 = l2.next;
            sb2.append(l2.val);
        }
        sb2.reverse();

        //通过BigInteger来大数相加
        BigInteger b1 = new BigInteger(sb1.toString());
        BigInteger b2 = new BigInteger(sb2.toString());
        sb1 = new StringBuffer(b1.add(b2).toString());
        //填回去还是要逆序的
        sb1.reverse();

        //填到新链表的过程 熟悉链表这一数据结构就很好理解 不知道的建议了解一下
        ListNode l3 = new ListNode(sb1.charAt(0) - '0');
        ListNode l4 = l3;
        int i = 0;
        while(++i < sb1.length()){
            ListNode l5 = new ListNode(sb1.charAt(i) - '0');
            l4.next = l5;
            l4 = l5; 
        }
        return l3;
    }
}

方法二:

方法一虽然过了，但时间和内存的消耗我并不满意，所以想出了方法二。方法二与方法一的不同就是不使用BigInteger和StringBuffer来轻松完成，而是完全靠链表特性来实现，这肯定会减少时间和内存的消耗

具体说不清楚，看注释吧，我为了节省空间丧心病狂了，写的难懂了，希望大家结合例子能搞懂

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //这个result就是要返回去的链表 注意 result指向的是l1的头节点 因为我打算将l1打造成和的链表 具体往下看
        ListNode result = l1;
        
        //第一部分
        //这个l3可以当做 l1的前节点 因为ListNode里只设了next指针，而没有prv指针，所以我设一个节点专门当l1的前节点
        ListNode l3;
        //n代表进位 两个节点相加超过10就进1 小学知识了
        int n = 0;
        do{
            //两节点和 加上 进位
            int m = l1.val + l2.val + n;
            //因为我上面说过将l1打造成和的链表 所以 直接将m % 10赋值给l1      % 10是因为每个节点只能存1位
            l1.val = m % 10;
            //求进位
            n = m / 10;
            //l3指向l1 
            l3 = l1;
        }while((l1 = l1.next) != null & (l2 = l2.next) != null);//l1和l2往后移 注意这里用& 而不是&&
        
        /*
        如果l1 = [9,9,9,9], l2 = [9,9,9,9,9,9,9]
        第一部分结束后 
        result = [8,9,9,9]
        l1 = null
        l2 = [9,9,9] (这是l2经过循环已经往后移动到第五个节点了)
        l3 = [9] 
        n = 1
        没看懂的建议跟着循环走几遍
        */
        

        //第二部分
        /*
        这个是精髓 为了不开新的节点浪费空间(虽然的确难懂了点，但链表了解了还是很好懂的)
        */
        if(l1 == null){
            //l3的作用来了，考虑到两个链表长度可能不一样 比如我上面举的例子
            l3.next = l2;
        }
        //到这里时 继续上面例子 result = [8,9,9,9,9,9,9] ，l3 = [9,9,9,9] (就是result后4个节点)

        //继续后半部分的计算 从l3那里开始 l3前面的节点在第一部分计算完了,如果n = 0也没必要算下去 result结果已经确定了
        while(l3.next != null && n == 1){
            l3 = l3.next;
            //只有进位了
            int m = l3.val + n;
            l3.val = m % 10;
            n = m / 10;
        }
        //到这里时 继续上面例子 result = [8,9,9,9,0,0,0] ，l3 = [0] (result最后一个节点)

        //怕到最后还有进位 那就最后开个新节点
        if(n == 1){
            l3.next = new ListNode(n);
        }
        //到这里时 继续上面例子 result = [8,9,9,9,0,0,0,1]

        return result;
    }
}