Posted by st3ady on Mon, 10 Jan 2022 06:32:50 +0100

Give you two non empty linked lists to represent two non negative integers. They store each number in reverse order, and each node can store only one number.

You can assume that neither number starts with 0 except the number 0.
Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [7,0,8]
Explanation: 342 + 465 = 807

Problem solving ideas
The problem of adding linked lists is very simple. You only need to write the expression to solve the problem at a glance. Take the example of this problem as an example: (2 - > 4 - > 3) + (5 - > 6 - > 4) = (7 - > 0 - > 8). According to the calculation process of addition, we know that we should start from the low order, that is, we should calculate 2 + 5 = 7 first, so the idea comes:

First, take out the lowest order of the two numbers on the left and right sides of "+", that is

```let val1 = l1.val
let val2 = l2.val
```

Secondly, find their sum and take it as the lowest bit of the output result (since the output result is saved in the form of linked list, we should write it in this form)

```let sum = new ListNode('0')
sum.next = new ListNode(""Results" % 10)//The reason why we want "result"% 10 is that our calculation result may be greater than 10, so we need to take the remainder
```

Therefore, the preliminary code is as follows:

```var addTwoNumbers = function(l1, l2) {
let sum = new ListNode('0') // Create a header linked list to save the results
while (l1 || l2) {//Execute the following logic on the premise that one of the two linked lists exists
let val1 = l1.val
let val2 = l2.val
let r1 = val1 + val2//Sum
sum.next = new ListNode(r1 % 10)//Next node of sum
sum = sum.next //sum points to the next node
if (l1) l1 = l1.next //l1 points to the next node to calculate the value of the second node
if(l2) l2 = l2.next //l2 points to the next node to calculate the value of the second node
}
return head.next //Returns the calculation result. The reason for using head Next is because the first node saved in the head is "0" defined at the beginning
};
```

The following is the start of optimization. As a college student, the first thing we should know is that the addition operation has carry, so consider adding carry to the code

```    let addOne = 0 //carry
let sum = new ListNode('0')
while (addOne || l1 || l2) {//Execute the following logic on the premise that one of the carry or two linked lists exists
let val1 = l1.val
let val2 = l2.val
let r1 = val1 + val2 + addOne//Sum
addOne = r1 >= 10 ? 1 : 0 // If the sum result > = 10, the carry is 1, otherwise it is 0
sum.next = new ListNode(r1 % 10)
sum = sum.next
if (l1) l1 = l1.next
if(l2) l2 = l2.next
}
};
```

Writing the above code is close to success, but it is still a step away from success. When we submit, we can't pass all cases. The case that can't pass is the addition of: [9999] and [99], because in the process of adding l1 and l2, when the pointer points to the third 9, the 9 of l1 exists, but the 9 of l2 does not exist, that is, it is null, Therefore, an error will be reported if the value cannot be added, so we need to carry out one-step optimization. If the value does not exist, set it to 0, and then add it. The completion code is as follows:

```var addTwoNumbers = function(l1, l2) {
let sum = new ListNode('0')
while (addOne || l1 || l2) {
let val1 = l1 !== null ? l1.val : 0 // Optimization point
let val2 = l2 !== null ? l2.val : 0 //Optimization point
let r1 = val1 + val2 + addOne
addOne = r1 >= 10 ? 1 : 0
sum.next = new ListNode(r1 % 10)
sum = sum.next
if (l1) l1 = l1.next
if (l2) l2 = l2.next
}
};
```

This solution is the most direct and universal. In the future, this idea can be adopted no matter how many numbers are added. I think if you learn more about the algorithm, you will draw inferences from one example slowly

code

```/**
* function ListNode(val, next) {
*     this.val = (val===undefined ? 0 : val)
*     this.next = (next===undefined ? null : next)
* }
*/
/**
* @param {ListNode} l1
* @param {ListNode} l2
* @return {ListNode}
*/
var addTwoNumbers = function(l1, l2) {
let sum = new ListNode('0')
while (addOne || l1 || l2) {
let val1 = l1 !== null ? l1.val : 0
let val2 = l2 !== null ? l2.val : 0
let r1 = val1 + val2 + addOne
addOne = r1 >= 10 ? 1 : 0
sum.next = new ListNode(r1 % 10)
sum = sum.next
if (l1) l1 = l1.next
if (l2) l2 = l2.next
}
};
```

Author: Afeng Xiu

The linked list needs to specify the position of the head change and set another pointer. Pay attention to the last carry and output 0 to remove the head next

```package com.kuang.LeetcodeStuddy;
public class leetcode2_1 {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode prev = new ListNode(0);
int carry = 0;
ListNode cur = prev;
while(l1!=null || l2!=null){
int x= l1 !=null ? l1.val : 0;
int y = l2 !=null ? l2.val : 0;
int sum = x + y + carry;
carry = sum / 10;
sum = sum % 10;
cur.next = new ListNode(sum);
cur = cur.next;
if(l1 !=null){
l1 = l1.next;
}
if(l2 !=null){
l2 = l2.next;
}
}
if(carry == 1){
cur.next = new ListNode(carry);
}
return prev.next;
}

public static void main(String[] args) {
//: l1 = [2,4,3], l2 = [5,6,4]
ListNode i1 = new ListNode(0);
ListNode l1 = i1;
l1.next = new ListNode(2);
l1 = l1.next;
l1.next = new ListNode(4);
l1 = l1.next;
l1.next = new ListNode(3);
l1 = l1.next;
System.out.println(i1.next);

ListNode i2 = new ListNode(0);
ListNode l2 = i2;
l2.next = new ListNode(5);
l2 = l2.next;
l2.next = new ListNode(6);
l2 = l2.next;
l2.next = new ListNode(4);
l2 = l2.next;
System.out.println(i2.next);

leetcode2 leetcode2 = new leetcode2();
System.out.println(listNode);
}
}
```

ListNode class

```package com.kuang.LeetcodeStuddy;

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; }

@Override
public String toString() {
return "ListNode{" +
"val=" + val +
", next=" + next +
'}';
}
}

```