Title description:
You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.
You may assume the two numbers do not contain any leading zero, except the number 0 itself.
Example 1:
Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [7,0,8]
Explanation: 342 + 465 = 807.
Example 2:
Input: l1 = [0], l2 = [0]
Output: [0]
Example 3:
Input: nums = [3,3], target = 6
Output: [0,1]
Constraints:
The number of nodes in each linked list is in the range [1, 100].
0 <= Node.val <= 9
It is guaranteed that the list represents a number that does not have leading zeros.
Time complexity: O(n+m)
simulated addition operation:
1. Enumerate two linked lists from the beginning at the same time, the value of sum is equal to the sum of the current elements of the l1 and l2 linked lists plus the value of the previous carry carry, and then sum% 10 The element of is stored in the dummy linked list, and the value of sum/10 is assigned to carry, l1 and l2 move backward at the same time
, and the loop termination condition. When all elements are traversed and carry == 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 dummy = new ListNode();
ListNode p = l1, q = l2, curr = dummy;
int carry = 0;
while(l1 != null || l2 != null || carry != 0){
int x = l1 == null ? 0:l1.val;
int y = l2 == null ? 0:l2.val;
int sum = x + y + carry;
carry = sum /10;
curr.next = new ListNode(sum % 10);
if(l1 != null) l1 = l1.next;
if(l2 != null) l2 = l2.next;
curr = curr.next;
}
return dummy.next;
}
}