链表算法三(两数相加力扣第二题)

两数相加力扣第二题

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

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

你可以假设除了数字 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]

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/two-sum

解题思路
找到较长的链表L 和较短的链表S.
第二次遍历while循环开始遍历,没遍历一次S指向S,next, while停止条件是S != null , 每遍历一次计算L .val+ S.val + 进位数的值,和除10的余数就是返回链表当前节点的值,进位数等于当前和除10的结果,
遍历结束后实际异常处理好了长短链表都有值得部分.
第二次遍历 处理长链表比短链表多的情况,求出当前节点值 + 进位数,这个节点值就是和除以10的余数,进位数等于除10的结果
处理进位数如果长链表遍历结束后,进位数还有1,那么应该在链表尾部追加一个新节点记录1

代码

package linkedlist.leetcode;

import java.util.Arrays;

public class LinedkListAdd {
    public static class ListNode {
        int val;
        ListNode next;

        ListNode() {
        }

        ListNode(int val) {
            this.val = val;
        }

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }

    public ListNode addTwoNumbers(ListNode listNode1, ListNode listNode2) {
        // 先判断边界
        if (listNode1 == null || listNode2 == null) {
            return listNode1 == null ? listNode2 : listNode1;
        }
        // 锁定长短链表
        ListNode l = getListNodeSize(listNode1) > getListNodeSize(listNode2) ? listNode1 : listNode2;
        ListNode s = l == listNode1 ? listNode2 : listNode1;
        // 创建返回节点
        ListNode resultListNode = l;
        // 创建跟踪节点 == > 跟踪长链表,因为长链表遍历结束肯定指向NULL
        // 所以如果需要补一位进位数,就得知道尾节点是什么
        ListNode trackNode = l;

        // 定义每次求和的sum
        int sum;
        // 定义进位数
        int temp = 0;

        // 遍历短链表 == > 两两求和 + 进位数
        while (s != null) {
            // sum  = 长链表值 + 短链表值 + 进位数
            sum = l.val + s.val + temp;
            // 当前节点位置的值就是sum的余数
            l.val = sum % 10;
            // 进位数被用了,重新赋值进位数
            temp = sum / 10;
            // 跟踪节点,跟踪长链表指向next节点前的节点
            trackNode = l;
            // 长短链表往下指继续遍历
            s = s.next;
            l = l.next;
        }

        // 短链表遍历结束,开始遍历只有长链表元素的情况
        while (l != null) {
            // 这个节点的和 = 当前节点值 + 进位数
            sum = l.val + temp;
            // 这个节点值应该是10的余数
            l.val = sum % 10;
            // 进位数重新赋值
            temp = sum / 10;
            // 跟踪节点,跟踪长链表指向next节点前的节点
            trackNode = l;
            // 长链表往下指继续遍历
            l = l.next;
        }

        // 长短链表全部遍历结束,如果进位数还剩1应该新添加节点
        if (temp != 0) {
            // 如果没有trackNode, 尾部指针就找不到了
            trackNode.next = new ListNode(1);
        }

        return resultListNode;
    }


    public static int getListNodeSize(ListNode listNode) {
        int resultInt = 0;
        while (listNode != null) {
            resultInt++;
            listNode = listNode.next;
        }
        return resultInt;
    }

    public static void main(String[] args) {
        ListNode listNode = new ListNode(3);
        listNode.next = new ListNode(7);
//        listNode.next.next = new ListNode(9);
//        listNode.next.next.next = new ListNode(9);
//        listNode.next.next.next.next = new ListNode(9);
//        listNode.next.next.next.next.next = new ListNode(9);
//        listNode.next.next.next.next.next.next = new ListNode(9);

        ListNode listNode2 = new ListNode(9);
        listNode2.next = new ListNode(2);
//        listNode2.next.next = new ListNode(9);
//        listNode2.next.next.next = new ListNode(9);

        LinedkListAdd linedkListAdd = new LinedkListAdd();
        ListNode listNode1 = linedkListAdd.addTwoNumbers(listNode, listNode2);
        System.out.println(listNode1);
    }
}