链表实现两个数相加

最新推荐文章于 2024-08-13 14:59:01 发布

hss_zl

最新推荐文章于 2024-08-13 14:59:01 发布

阅读量2.9k

点赞数 1

分类专栏： LeetCode 文章标签：链表 Java

本文链接：https://blog.csdn.net/hsz_zl/article/details/53349779

版权

LeetCode 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

给两个链表，每个节点存储一个数字，实现两个节点之间的数字相加，返回相加后的数字链表

第一版的程序

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode l3 = new ListNode(0);
        ListNode res = l3;
        int value = 0;
        int flag = 0;
        while (l1 != null || l2 != null || flag == 1) {
            int sum = 0;
            l3.next = new ListNode(0);
            if (l1 != null && l2 != null) {
                sum = l1.val + l2.val + flag;
                l1 = l1.next;
                l2 = l2.next;
            } else if (l1 != null && l2 == null) {
                sum = l1.val + flag;
                l1 = l1.next;
            } else if (l1 == null && l2 != null) {
                sum = l2.val + flag;
                l2 = l2.next;
            } else {
                sum = flag;
            }
            value = sum % 10;
            flag = sum / 10;
            l3.next.val = value;
            l3 = l3.next;
        }
        return res.next;
    }
}

分析
- 两个链表存储的数字是依次从低位到高位的，每个节点上的数字是从0~9，低位的数字相加如果大于等于10需要向高位进一位。
- 两个数做加法操作时，对应的是每位上的数字的相加，其实还有进位，所以说其实共有三部分的数字进行相加。
- 两个链表有一个不为空，以及进位不为零时，都应该进行相加的操作，所以while循环中是三者有一个满足时，都会执行循环体的操作。
- 求和，是三者的和，如果有一个或者两个不存在时，就只用其余的一个或两个求和。
- 新生成一个l3链表，l3链表的值等于和对10求余数。
- 更新标志位，标志位为和除以10的商。
缺点
- l3链表可以不用生成，因为可以将l1链表或者是l2链表存储计算后的值，如果最后的结果超出了两个链表中最大长度的一个链表，可以生成新的节点用于保存新生成的值，这样可以节约空间。
- 计算和的时候，每一个判断条件对应的计算公式中都要加上判断标志位，可以对此进行优化。

第二版的程序（根据上面的缺点第二条进行优化）

while (l1 != null || l2 != null || flag == 1) {
            int sum = flag;
            l3.next = new ListNode(0);
            if (l1 != null && l2 != null) {
                sum += l1.val + l2.val;
                l1 = l1.next;
                l2 = l2.next;
            } else if (l1 != null && l2 == null) {
                sum += l1.val;
                l1 = l1.next;
            } else if (l1 == null && l2 != null) {
                sum += l2.val;
                l2 = l2.next;
            } 
            value = sum % 10;
            flag = sum / 10;
            l3.next.val = value;
            l3 = l3.next;
        }

分析
- 上面的缺点已经分析过改进的必要性，这里关注下改进前后的运行时间，第一版运行时间是56ms，第二版运行时间是50ms

第三版程序（改进缺点的第一条）

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode pre1 = new ListNode(0);
        ListNode pre2 = new ListNode(0);
        pre1.next = l1;
        pre2.next = l2;
        int value = 0;
        int flag = 0;
        while (pre1.next != null || pre2.next != null || flag == 1) {
            int sum = flag;
            if (pre1.next != null && pre2.next != null) {
                sum += pre1.next.val + pre2.next.val;
                pre1.next.val = sum % 10;
                pre1 = pre1.next;
                pre2 = pre2.next;
                flag = sum / 10;
                continue;
            } else if (pre1.next != null && pre2.next == null) {
                sum += pre1.next.val;
                pre1.next.val = sum % 10;
                pre1 = pre1.next;
                flag = sum / 10;
                continue;
            } else if (pre1.next == null && pre2.next != null) {
                sum += pre2.next.val;
                pre2 = pre2.next;
            }
            pre1.next = new ListNode(sum % 10);
            pre1 = pre1.next;
            flag = sum / 10;
        }
        return l1;
    }
}

分析
- 减少了空间，运行的速度变成了47ms

简化代码版

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode l3 = new ListNode(0);
        ListNode res = l3;
        int value = 0;
        int flag = 0;
        while (l1 != null || l2 != null || flag == 1) {
            int sum = flag;
            sum += (l1 != null ? l1.val : 0) + (l2 != null ? l2.val : 0);
            l1 = (l1 != null ? l1.next : null);
            l2 = (l2 != null ? l2.next : null);
            l3.next = new ListNode(sum % 10);
            flag = sum / 10;
            l3 = l3.next;
        }
        return res.next;
    }
}

分析
- 运行的速度并不好（运行的时间每次都不固定）

心得

为链表生成一个链表头，并用l.next来判断链表，可以防止在遍历到最后一个链表的时候，丢弃最后一个链表的索引。如果在遍历到最后一个链表的时候，l.next为空，l指向的是最后一个链表的节点；如果用l来判断链表是否为空，只能将最后一个链表的next赋给l时，才知道链表已经为空了，此时l的指向就无意义了。