题解 | #牛群的能量值# java

 import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param l1 ListNode类 
     * @param l2 ListNode类 
     * @return ListNode类
     */
    public ListNode addEnergyValues (ListNode l1, ListNode l2) {
        // write code here
ListNode dummyHead = new ListNode(0); // 虚拟头节点
        ListNode curr = dummyHead; // 当前节点
        int carry = 0; // 进位值

        while (l1 != null || l2 != null) {
            int sum = carry;

            if (l1 != null) {
                sum += l1.val;
                l1 = l1.next;
            }

            if (l2 != null) {
                sum += l2.val;
                l2 = l2.next;
            }

            int digit = sum % 10; // 个位数
            carry = sum / 10; // 进位值

            curr.next = new ListNode(digit);
            curr = curr.next;
        }

        if (carry > 0) {
            curr.next = new ListNode(carry);
        }

        return dummyHead.next;
    }
}

知识点：

• 链表的数据结构
• 链表的基本操作
• 逆序相加

解释提要：上述代码定义了一个 ListNode 类，用于表示链表节点，包含一个整数值和一个指向下一个节点的指针。另外还定义了一个 Solution 类，其中包含一个方法 addTwoNumbers，用于将两个逆序链表表示的整数相加。

具体步骤如下：

1. 创建一个虚拟头节点 dummyHead，并将当前节点 curr 初始化为虚拟头节点。
2. 定义一个进位值 carry，初始值为 0。
3. 遍历两个链表 l1 和 l2，直到两个链表都遍历完。
4. 在每一次循环中，首先将进位值 carry 加到当前和 sum 中。
5. 如果链表 l1 不为空，则将 l1 的当前节点值加到 sum 中，并将 l1 指针移向下一个节点。
6. 如果链表 l2 不为空，则将 l2 的当前节点值加到 sum 中，并将 l2 指针移向下一个节点。
7. 将 sum 对 10 取余得到当前位的数字，并将 sum 除以 10 得到新的进位值。
8. 创建一个新的节点，并将当前位的数字作为值赋给该节点，将该节点连接到当前节点的后面。
9. 更新当前节点指针 curr。
10. 重复步骤 3-9，直到两个链表都遍历完。
11. 最后，如果进位值 carry 大于 0，则创建一个新的节点，将 carry 作为值赋给该节点，并将该节点连接到当前节点的后面。
12. 返回虚拟头节点的后继节点，即和的链表头节点。

通过以上步骤，可以将两个逆序链表表示的整数相加，并以相同的逆序形式返回表示和的链表。该算法的时间复杂度为O(max(N, M))，其中N和M分别是两个链表的长度。