LeetCode 2. 两数相加

大梦想像太阳

已于 2024-04-14 19:20:53 修改

阅读量815

点赞数 25

分类专栏： LeetCode 文章标签： leetcode 算法职场和发展

于 2024-04-12 23:50:51 首次发布

本文链接：https://blog.csdn.net/qq_63939626/article/details/137698401

版权

LeetCode 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本文详细介绍了使用Java实现链表相加的三种方法：迭代法（包含普通版和优化版）、递归法，探讨了它们的时间复杂度和空间复杂度。

摘要由CSDN通过智能技术生成

一、题目

二、解题

注：本文均是Java代码

1、迭代法（思路版）

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 哨兵节点
        ListNode sentinel = new ListNode(-1);
        // 结果的指针p
        ListNode p = sentinel;
        // carry等于1进位，等于0不进
        int carry = 0;
        // 当l1和l2都不为空时进入循环
        while (l1 != null && l2 != null) {
            // l1节点值、l2节点值、进位的和
            int sum = l1.val + l2.val + carry;
            // sum大于等于10进1
            if (sum >= 10) {
                // 进位1
                carry = 1;
                // 进位后余下的值
                sum -= 10;
            }
            else {
                carry = 0;
            }
            p.next = new ListNode(sum);
            // l1、l2、p节点右移
            l1 = l1.next;
            l2 = l2.next;
            p = p.next;
        }
        // 如果链表一长一短，短的循环完毕后，长的还要自己循环
        // pp指向较长的链表继续循环
        ListNode pp = l1 != null ? l1 : l2;
        while (pp != null) {
            int sum = pp.val + carry;
            if (sum >= 10) {
                carry = 1;
                sum -= 10;
            }
            else {
                carry = 0;
            }
            p.next = new ListNode(sum);
            pp = pp.next;
            p = p.next;
        }
        // 最后两位加和大于等于10，还需要像高位进1，再加一个节点
        if (carry == 1) p.next = new ListNode(1);
        // 返回的结果从哨兵节点下一个节点开始
        return sentinel.next;
    }
}

2、迭代法（优化版）

利用carry变量存储和，减少了一个sum变量，把三种情况合在一个循环中简化代码。

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 时间复杂度O(n)
        // 空间复杂度O(1)
        // 哨兵节点
        ListNode sentinel = new ListNode(-1);
        // 结果的指针，初始指向哨兵节点
        ListNode p = sentinel;
        int carry = 0;
        // 当链表l1不为空或l2不为空或carry等于0进入循环
        while (l1 != null || l2 != null || carry != 0) {
            if (l1 != null) {
                // 直接利用carry，少一个
                carry += l1.val;
                // 链表l1指针右移
                l1 = l1.next;
            }
            if (l2 != null) {
                carry += l2.val;
                // 链表l1指针右移
                l2 = l2.next;
            }
            p = p.next = new ListNode(carry%10);
            carry /= 10;
        }
        // 返回的结果是从哨兵节点的下一个节点开始
        return sentinel.next;
    }
}

3、递归法

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 时间复杂度O(n)
        // 空间复杂度O(n)
        return twoSum(l1,l2,0);
    }
    private ListNode twoSum(ListNode l1, ListNode l2, int carry) {
        // 循环结束条件，当l1和l2都为空时
        if (l1 == null && l2 == null) {
            // 如果最后两个结点和大于等于10，需要向高位进1，新增一个节点，而且值一定为1
            return carry == 0 ? null : new ListNode(carry);
        }
        // 如果链表一长一短，全都转为为1l是长的情况
        if (l1 == null) {
            l1 = l2;
            l2 = null;
        }
        // 节点值和进位值加在一起，l2为空时不加l2的值
        carry = carry + l1.val + (l2 == null ? 0 : l2.val);
        // 节点保留一个数位
        l1.val = carry % 10;
        // 移动到下一个节点进行递归
        l1.next = twoSum(l1.next, (l2 == null ? null : l2.next), carry/10);
        return l1;
    }
}