LeetCode题库链表求和java实现

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

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

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

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

 这道题首先需要理解这里的链表，链表的每个节点都是保存的当前节点的值和指向下个节点的指针。每个节点都是通过节点中保存的指针进行链接。

public class ListNode {
    public int val;
    public ListNode next;   // 下一个链表对象
    //赋值链表的值
    public ListNode(int x)
    {
        val = x;
    }
}

下面是我理解官网和大神的解法后自己写的，注释是自己的理解希望对你有帮助。

 public ListNode addTwo(ListNode l1,ListNode l2){
        //思路是逐个节点单独的相加，节点大于10的话会产生进位1放到下一个节点去相加，不大于10就放在当前节点
        ListNode resulttag = new ListNode(0);
        ListNode result = new ListNode(0);//最终返回的链表
        //result = resulttag;
        resulttag = result;
        ListNode l1tag = l1;
        ListNode l2tag = l2;
        int sum = 0;//求和数据
        int carry = 0;//进位数值
        //遍历第一个链表
        while(l1tag != null){
            //当第二个链表是空的时候
            if (l2tag == null){
                //获取l1当前的值
                int n1 = l1tag != null ? l1tag.val : 0;
                //求和 计算n1和进位的和
                sum = n1 + carry;
                //主节点赋值，取10的余数，多的进位放到后面加到下一个节点
                result.val = sum%10;
                //初始化进位值
                carry = 0;
                if (sum>=10){
                    //有进位时给进位赋值
                    carry = 1;
                }
                // l1下推，这个下推必须放到生成结果链表生产节点之前，否则最后生成的会多一个0节点
                l1tag = l1tag.next;
                if (l1tag != null||carry !=0){
                    //主节点下移
                    result.next = new ListNode(0);
                    result = result.next;
                }

            }
            if (l2tag != null){
                //l1、l2均不为空的时候获取两个节点的值
                int n1 = l1tag != null ? l1tag.val : 0;
                int n2 = l2tag != null ? l2tag.val : 0;
                //求和
                 sum = n1 + n2 + carry;
                 //给主节点赋值
                result.val = sum%10;
                //初始化进位
                carry =0;
                if (sum>=10){
                    //进位赋值
                    carry = 1;
                }
                //l1、l2 节点下推，也必须放在结果链表节点下推之前以避免多生成一个空节点
                l1tag = l1tag.next;
                l2tag = l2tag.next;
                if (l1tag != null|| l2tag != null ||carry !=0){
                    result.next = new ListNode(0);//结果链表下移
                    result = result.next;
                }
            }
        }
        //l2 节点多的时候继续遍历，此时l1已经遍历完了
        while(l2tag != null){
            //获取l2节点的值
            int n2 = l2tag != null ? l2tag.val : 0;
            //求和
            sum = n2 + carry;
            //给结果链表赋值
            result.val = sum%10;
            //初始化进位
            carry = 0;
            if (sum>=10){
                //进位赋值
                carry =1;
            }
            //l2节点下移，必须放在结果链表下移前面，如果为空结果链表不可以下移
            l2tag =l2tag.next;
            //l2下移的节点不为空或者进位不为0才可以下移结果链表
            if (l2tag != null|| carry !=0){
                result.next = new ListNode(0);
                result = result.next;
            }

        }
        //最后一次进位计算，当两个链表遍历完成后最后还产生进位就放到下一个节点
        if (l1tag == null&&l2tag == null&& carry>0){
            result.val = carry;
            carry =0;
        }
        return resulttag;
    }