3. LeetCode-2 两数相加

最新推荐文章于 2024-11-02 15:52:57 发布

zf xia

最新推荐文章于 2024-11-02 15:52:57 发布

阅读量67

点赞数

分类专栏：每日一题 java基础文章标签： java leetcode

本文链接：https://blog.csdn.net/qq_43021651/article/details/117755119

版权

每日一题同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

java基础

4 篇文章 0 订阅

订阅专栏

引用：LeetCode 第2题两数相加

1. 描述

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

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

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

2. 解题思路

同时遍历两个链表，对应的节点的值相加，当其中一个链表遍历完后其值为0，需要注意的是进位问题。

普通法：遍历两个链表，直到两个链表都遍历完成；
普通法-优化：当一个链表遍历宏完后且没有进位，把另一个链表余下的节点直接指向结果的尾部指针；

2.1 普通法

同时遍历两个链表，把对应节点的值相加再加上进位的值得到当前节点的总值，总值取10的模数得到当前节点的值，总值除于10得到下一节点的进位值。

/**
 * 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) {
        // 存放结果的链表 的头节点
        ListNode head = new ListNode();
        ListNode tail = head;
        // 临时节点 过度节点
        ListNode temp = null;
        // 表示进位的值
        int carry = 0;
        while (l1 != null || l2 != null || carry > 0) {
            int i1 = 0;
            int i2 = 0;
            if (l1 != null) {
                i1 = l1.val;
                l1 = l1.next;
            }
            if (l2 != null) {
                i2 = l2.val;
                l2 = l2.next;
            }

            // 计算当前位的总数值
            int i = i1 + i2 + carry;

            // 是否进位
            carry = i / 10;
            temp = new ListNode(i % 10);

            // 尾部的下个节点指向临时节点
            tail.next = temp;

            // 移动尾部节点指向最后一个节点
            tail = temp;
        }
        return head.next;
    }
}

2.2 普通法-优化

在遍历的循环中增加循环中止条件，即有一个链表已经遍历完了且没有进位（进位值为0）。

/**
 * 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) {
        // 存放结果的链表 的头节点
        ListNode head = new ListNode();
        ListNode tail = head;
        // 临时节点 过度节点
        ListNode temp = null;
        // 表示进位的值
        int carry = 0;
        // 表示是否有结点为空
        boolean isNull = false;
        while (l1 != null || l2 != null || carry > 0) {
            int i1 = 0;
            int i2 = 0;
            if (l1 != null) {
                i1 = l1.val;
                l1 = l1.next;
            } else {
                isNull = true;
            }
            if (l2 != null) {
                i2 = l2.val;
                l2 = l2.next;
            } else {
                isNull = true;
            }

            // 计算当前位的总数值
            int i = i1 + i2 + carry;

            // 是否进位
            carry = i / 10;
            temp = new ListNode(i % 10);

            // 尾部的下个节点指向临时节点
            tail.next = temp;

            // 移动尾部节点指向最后一个节点
            tail = temp;

            // 判断是否具备退出条件，退出前把 tail 指向 非空的 l1 或 l2 
            if (isNull && carry == 0) {
                tail.next = l1 == null ? l2 : l1;
                break;
            }
        }
        return head.next;
    }
}