链表节点数字相加（牛客TOP101.BM11, 力扣HOT100.2）

针对牛客的TOP101的BM11( 链表相加（二）)和力扣的HOT100第2题(两数相加)对比分析。

BM11:

实例：

输入： [9,3,7],[6,3] 

输出： {1,0,0,0}

解析：可知，链表最后一个节点是个位，然后依次向前是百位，千位.....，我们相加都是先从个位加起，然后百位.....（中间要考虑进位），因此，采用栈的方式，利用栈的先进后出，获取链表尾部（个位），然后依次出栈相加，获得新的值，存入新的链表中(头插法)，最终输出。

代码：

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param head1 ListNode类 
     * @param head2 ListNode类 
     * @return ListNode类
     */
    public ListNode addInList (ListNode head1, ListNode head2) {
        // write code here
        //特殊情况
        if (head1 == null){
            return head2;

        }
        if (head2 == null){
            return head1;
        }
        //两个辅助栈
        Stack<ListNode> s1 = new Stack<>();
        Stack<ListNode> s2 = new Stack<>();

        ListNode h1 = head1;
        ListNode h2 = head2;
        //两个链表依次入栈
        while (h1!= null){
            s1.push(h1);
            h1 = h1.next;
        }
        while (h2 != null){
            s2.push(h2);
            h2 = h2.next;
        }
        //进位
        int temp = 0;

        //创建新链表，
        ListNode newHead = null;
        //当s1或s2不为空的时候
        while (!s1.isEmpty() || !s2.isEmpty()){
            int val = temp;
            if (!s1.isEmpty()){
                val += s1.pop().val;
            }
            if (!s2.isEmpty()){
                val+=s2.pop().val;
            }

            //判断进位
            temp = val/10;
            //头插法，val%10是，如果存在进位的话，应该只取个位，比如说
            //s1的值是7，s2的值是8，两者相加后，得15，因此，进位是1，而新节点的值是5
            ListNode node = new ListNode(val%10);
            node.next = newHead;
            newHead = node;


        }

        //判断第一位
        if (temp > 0){
            ListNode node = new ListNode(temp);
            node.next = newHead;
            newHead = node;
        }

        return newHead;
    }
}

力扣HOT100.2:

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

 实例：

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

解析：链表第一个节点是个位，然后依次向后是百位，千位.....。因此，我们可以不借助栈，直接用链表从一个节点进行相加，获得新的值，存入新的链表中（尾插法），最终输出。

代码：

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //新链表，有虚拟头节点
        ListNode newHead = new ListNode(-1);

        ListNode cur = newHead;
        //进位
        int temp = 0;

        while (l1!=null || l2!=null){

            int val = temp;
            if (l1!=null){
                val+=l1.val;
                l1=l1.next;
            }

            if (l2!=null){
                val+=l2.val;
                l2=l2.next;
            }

            temp = val/10;

            ListNode node = new ListNode(val%10);
            //尾插法建立链表
            cur.next=node;
            cur = cur.next;

        }

        //判断最后一位
        if (temp > 0){
            ListNode node = new ListNode(temp);
            cur.next= node;
        }
        //输出跳过虚拟头节点
        return newHead.next;
    }

还有一位大佬用的递归解决，代码如下。

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {

        return add(l1,l2,0);

    }

    //递归求解每一个节点的值，bit为进位
    public ListNode add(ListNode l1,ListNode l2,int bit){
        if (l1==null && l2==null && bit == 0){
            return null;
        }

        int val = bit;
        if (l1!=null){
            val+=l1.val;
            l1=l1.next;
        }

        if (l2!=null){
            val+=l2.val;
            l2=l2.next;
        }

        ListNode node = new ListNode(val%10);
        node.next=add(l1,l2,val/10);

        return node;


    }