LeetCode 链表两数相加⭐️

夜阑卧听风吹雨，铁马冰河入梦来

已于 2024-09-03 10:07:25 修改

阅读量1.3k

点赞数 41

分类专栏：数据结构与算法基础文章标签： leetcode 链表算法

于 2024-08-12 11:10:27 首次发布

本文链接：https://blog.csdn.net/lingxiyizhi_ljx/article/details/141124995

版权

数据结构与算法基础专栏收录该内容

33 篇文章 0 订阅

订阅专栏

题目描述

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

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

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

题目解析

上边题目这么多，其实就是两个数用链表倒序表示，然后对应位置相加，如果和大于10，就进位，最终要返回新的链表表示两数之和

思路

可以使用模拟的方法，两个链表对应位置相加，只是特殊场景比较多，此外还涉及到最终场景是否进位，是否需要创建链表对象。

定义指针分别指向链表的第一个元素处，然后依次计算对应位置和的场景。

正常情况，指针指向链表1和2的相同位置，如果指针指向的都非null，那么就先计算和，然后指针1和2都后移，

计算完后移动链表1和2的位置

如果其中一个为null,和的运算也只需要计算不为null的那个，只需要不为null的指针后移

比如

还需要定义两个变量addNum 表示进位的数，没有进位就是0，currentVal,表示当前位置上计算后的值，比如2+3，是5，如果超过10，比如7+6，addNum就是1，currentVal=3

然后就是将表示结果的链表指针，赋值val为currentVal

current1和current2已经后移了

同时这里需要处理好最后一个节点的场景,此时需要注意，current1和current2已经指向了下一个元素了

如果current1和current2指向至少一个不为null，那么说明肯定有下一个和，也就肯定有下一轮的计算

所以，创建一个指针表示结果指向的next，然后将当前指针后移

如果两个都为空，那么还需要根据addNum,区分是否创建下一个元素

addNum=0就不用了说明已经到达了结尾，直接返回即可

addNum！=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 current1 = l1; //定义指针指向l1
        ListNode current2 = l2;//定义指针指向l1
        ListNode l3 = new ListNode(0, null); //定义指针指向l3
        ListNode l3H = new ListNode(0, l3);//定义虚拟头指向l3
        int addNum = 0;//进位
        while (current1 != null || current2 != null) {//结束条件，两个指针都指向了空
            int he = 0;//对应位置和
            //都不为null
            if (current1 != null && current2 != null) {
                //计算和
                he = current1.val + current2.val + addNum;
                //后移指针
                current1 = current1.next;
                current2 = current2.next;
            } else if (current1 == null && current2 != null) {
                //current1=null;计算和，移动current2
                he = current2.val + addNum;
                current2 = current2.next;
            } else if (current2 == null && current1 != null) {
                //current2=null;计算和，移动current1
                he = current1.val + addNum;
                current1 = current1.next;
            }
            //当前位置值
            int currenVal = 0;
            //和大于=10，记进位1，当前位置值为取模
            if (he >= 10) {
                addNum = 1;
                currenVal = he % 10;
            } else {
                //小于10，进位0，当前值就是和
                addNum = 0;
                currenVal = he;
            }
            l3.val = currenVal;//l3赋值
            //下一个指针指向的都是null,说明已经到了结尾
            if (current1 == null && current2 == null) {
                //进位决定是否需要再添加一个末尾元素，如最后是9+9，还需要再添加一个末尾元素
                if (addNum != 0) {
                    ListNode listNode = new ListNode(addNum, null);
                    l3.next = listNode;
                } else {
                    //没有就直接指向null
                    l3.next = null;

                }
                //已经到了末尾返回即可
                return l3H.next;
            } else {
                //下一个指针指向的至少一个不是null,创建指针，next指向下一个，然后移动l3,进入下一轮循环
                ListNode next = new ListNode(0, null);
                l3.next = next;
                l3 = next;
            }

        }
        return l3H.next;
    }
}

不用虚拟头指针的方法，定义指针变量p,指向l3

/**
 * 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 current1 = l1; //定义指针指向l1
        ListNode current2 = l2;//定义指针指向l1
        ListNode l3 = new ListNode(0, null); //定义指针指向l3
        ListNode p =l3;
        int addNum = 0;//进位
        while (current1 != null || current2 != null) {//结束条件，两个指针都指向了空
            int he = 0;//对应位置和
            //都不为null
            if (current1 != null && current2 != null) {
                //计算和
                he = current1.val + current2.val + addNum;
                //后移指针
                current1 = current1.next;
                current2 = current2.next;
            } else if (current1 == null && current2 != null) {
                //current1=null;计算和，移动current2
                he = current2.val + addNum;
                current2 = current2.next;
            } else if (current2 == null && current1 != null) {
                //current2=null;计算和，移动current1
                he = current1.val + addNum;
                current1 = current1.next;
            }
            //当前位置值
            int currenVal = 0;
            //和大于=10，记进位1，当前位置值为取模
            if (he >= 10) {
                addNum = 1;
                currenVal = he % 10;
            } else {
                //小于10，进位0，当前值就是和
                addNum = 0;
                currenVal = he;
            }
            p.val = currenVal;//l3赋值
            //下一个指针指向的都是null,说明已经到了结尾
            if (current1 == null && current2 == null) {
                //进位决定是否需要再添加一个末尾元素，如最后是9+9，还需要再添加一个末尾元素
                if (addNum != 0) {
                    ListNode listNode = new ListNode(addNum, null);
                    p.next = listNode;
                } else {
                    //没有就直接指向null
                    p.next = null;

                }
                //已经到了末尾返回即可
                return l3;
            } else {
                //下一个指针指向的至少一个不是null,创建指针，next指向下一个，然后移动l3,进入下一轮循环
                ListNode next = new ListNode(0, null);
                p.next = next;
                p = next;
            }

        }
        return l3;
    }
}