LeetCode 0002「两数相加」

我是陈皮，一个在互联网 Coding 的 ITer，个人微信公众号「陈皮的JavaLib」关注第一时间阅读最新技术文章。

题目

---

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。请你将两个数相加，并以相同形式返回一个表示和的链表。假设除了数字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

分析

---

两个数相加，一般是从低位到高位，同位置数字相加，如果有进位，进位需要与高位再进行相加。即相同位置的两个数相加后，用新节点保存相加后的个位数值，用进位变量保存相加后的十位数值，然后进位变量再参与高位的计算。

考虑存储空间问题，以及是否可以改变原有链表数据的情况下，可以有2种算法实现：

1. 不可改变原有链表数据情况下，新链表的所有节点都是新生成的；
2. 可以改变原有链表数据情况下，新链表的节点可以复用原有链表的节点；

实现

---

package com.chenpi;

/**
 * 节点类
 */
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;
    }

    @Override
    public String toString() {
        return "ListNode{" + "val=" + val + '}';
    }
}


/**
 * @Description 两数相加
 * @Author Mr.nobody
 * @Date 2021/1/22
 * @Version 1.0
 */
class Solution {

    // 新链表的每个节点都是新生成（不可以改变原有链表数据的情况下）
    public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 表头，主要为后面连接下一个节点保持同样操作
        ListNode headNode = new ListNode();
        // 游标
        ListNode cursor = headNode;
        // 进位
        int temp = 0;
        // 同时遍历2个链表的所有数据，同时是为了保证2个链表的相同位置数据进行相加处理
        while (null != l1 || null != l2 || 0 != temp) {
            // 当前节点（位数）不为空
            if (null != l1) {
                // 加上此节点数值
                temp += l1.val;
                // 指向下一个节点
                l1 = l1.next;
            }
            if (null != l2) {
                // 加上此节点数值
                temp += l2.val;
                // 指向下一个节点
                l2 = l2.next;
            }
            // 生成新节点，保留相加后的个位数值
            cursor.next = new ListNode(temp % 10);
            // 游标指向新链表的新节点
            cursor = cursor.next;
            // 保留相加后十位数值(即进位)
            temp = temp / 10;
        }
        // 返回实际表头
        return headNode.next;
    }

    // 利用原有链表的节点，节省存储空间（前提是可以改变原有链表的数据）
    public static ListNode addTwoNumbers1(ListNode l1, ListNode l2) {
        // 表头，主要为后面连接下一个节点保持同样操作
        ListNode headNode = new ListNode();
        // 游标
        ListNode cursor = headNode;
        // 进位，保存每次低位2个数相加后的进位
        int temp = 0;
        // 同时遍历2个链表的所有数据，同时是为了保证2个链表的相同位置数据进行相加处理
        while (null != l1 || null != l2) {
            // 当前节点（位数）不为空
            if (null != l1) {
                // 加上此节点数值
                temp += l1.val;
                // 当前节点的值已经没用，可以利用此节点作为新的链表的节点，节省存储空间(如果l2节点不为空，会被l2节点代替)
                cursor.next = l1;
                // 指向下一个节点
                l1 = l1.next;
            }
            if (null != l2) {
                // 加上此节点数值
                temp += l2.val;
                // 当前节点的值已经没用，可以利用此节点作为新的链表的节点，节省存储空间
                cursor.next = l2;
                // 指向下一个节点
                l2 = l2.next;
            }
            // 游标指向新链表的新节点
            cursor = cursor.next;
            // 保留相加后的个位数值
            cursor.val = temp % 10;
            // 保留相加后十位数值(即进位)
            temp = temp / 10;
        }
        // 如果最后进行不为空，需要加上此进位
        if (0 != temp) {
            cursor.next = new ListNode(temp);
        }
        // 返回实际表头
        return headNode.next;
    }

    public static void main(String[] args) {
        ListNode l1 = new ListNode(0);
        l1.next = new ListNode(1);
        l1.next.next = new ListNode(8);
        // 打印原有链表1
        ListNode l1temp = l1;
        while (null != l1temp) {
            System.out.print(l1temp + " ");
            l1temp = l1temp.next;
        }
        System.out.println();

        ListNode l2 = new ListNode(0);
        l2.next = new ListNode(9);
        // 打印原有链表2
        ListNode l2temp = l2;
        while (null != l2temp) {
            System.out.print(l2temp + " ");
            l2temp = l2temp.next;
        }
        System.out.println();

        // 打印相加后新链表
        ListNode newNode = addTwoNumbers1(l1, l2);
        while (null != newNode) {
            System.out.print(newNode + " ");
            newNode = newNode.next;
        }
    }
}

输出结果

ListNode{val=0} ListNode{val=1} ListNode{val=8} 
ListNode{val=0} ListNode{val=9} 
ListNode{val=0} ListNode{val=0} ListNode{val=9} 

Leetcode 执行结果

本次分享到此结束啦~~

如果觉得文章对你有帮助，点赞、收藏、关注、评论，您的支持就是我创作最大的动力！