Add Two Numbers Represented as Linked List in DSA Javascript

Mental Model

We add two numbers digit by digit like in school, but each digit is a node in a linked list. We move through both lists together, carrying over when sum is 10 or more.

Analogy: Imagine adding two numbers on paper from right to left, carrying over extra tens. Here, each digit is a box in a chain, and we add box by box.

List1: 2 -> 4 -> 3 -> null
List2: 5 -> 6 -> 4 -> null
Result: ? -> ? -> ? -> null

Dry Run Walkthrough

Input: list1: 2->4->3 (represents 342), list2: 5->6->4 (represents 465)

Goal: Add the two numbers and return the sum as a linked list in the same reversed order

Step 1: Add first nodes: 2 + 5 = 7, no carry

Result: 7 -> null

Why: Start adding from least significant digit, store sum digit

Step 2: Add second nodes: 4 + 6 = 10, store 0 and carry 1

Result: 7 -> 0 -> null

Why: Sum is 10, so digit is 0 and carry 1 to next addition

Step 3: Add third nodes plus carry: 3 + 4 + 1 = 8, no carry

Result: 7 -> 0 -> 8 -> null

Why: Add last digits and carry, store sum digit

Result:

7 -> 0 -> 8 -> null (represents 807)

Annotated Code

DSA Javascript

class ListNode {
  constructor(val = 0, next = null) {
    this.val = val;
    this.next = next;
  }
}

function addTwoNumbers(l1, l2) {
  let dummyHead = new ListNode(0);
  let current = dummyHead;
  let carry = 0;

  while (l1 !== null || l2 !== null || carry !== 0) {
    let val1 = l1 ? l1.val : 0;
    let val2 = l2 ? l2.val : 0;
    let sum = val1 + val2 + carry;
    carry = Math.floor(sum / 10);
    current.next = new ListNode(sum % 10);
    current = current.next;

    if (l1 !== null) l1 = l1.next;
    if (l2 !== null) l2 = l2.next;
  }

  return dummyHead.next;
}

// Helper to print list
function printList(node) {
  let result = '';
  while (node !== null) {
    result += node.val + ' -> ';
    node = node.next;
  }
  result += 'null';
  return result;
}

// Driver code
const l1 = new ListNode(2, new ListNode(4, new ListNode(3)));
const l2 = new ListNode(5, new ListNode(6, new ListNode(4)));
const sumList = addTwoNumbers(l1, l2);
console.log(printList(sumList));

while (l1 !== null || l2 !== null || carry !== 0) {

continue adding while any list has nodes or carry exists

let val1 = l1 ? l1.val : 0;

get current digit from first list or 0 if none

let val2 = l2 ? l2.val : 0;

get current digit from second list or 0 if none

let sum = val1 + val2 + carry;

sum current digits plus carry

carry = Math.floor(sum / 10);

calculate carry for next digit

current.next = new ListNode(sum % 10);

store digit part of sum in new node

current = current.next;

move pointer to newly added node

if (l1 !== null) l1 = l1.next;

advance first list pointer

if (l2 !== null) l2 = l2.next;

advance second list pointer

Output

7 -> 0 -> 8 -> null

Complexity Analysis

Time: O(n) because we traverse both linked lists once where n is the longer list length

Space: O(n) because the result list can be at most one node longer than the longer input list

vs Alternative: Compared to converting lists to numbers and back, this approach avoids large integer handling and works digit by digit efficiently

Edge Cases

One list is empty

Returns the other list as the sum

DSA Javascript

while (l1 !== null || l2 !== null || carry !== 0) {

Sum has an extra carry digit (e.g., 5 + 5 = 10)

Adds an extra node for carry at the end

DSA Javascript

while (l1 !== null || l2 !== null || carry !== 0) {

Lists of different lengths

Continues adding with 0 for missing nodes

DSA Javascript

let val1 = l1 ? l1.val : 0;

When to Use This Pattern

When you see two linked lists representing numbers and need to add them digit by digit, use this pattern to simulate addition with carry.

Common Mistakes

Mistake: Not handling carry after the last nodes are processed
Fix: Include carry in the while loop condition to add extra node if needed

Mistake: Advancing pointers without checking if they are null
Fix: Check if pointer is not null before moving to next node

Summary

Adds two numbers represented as reversed linked lists digit by digit with carry.

Use when adding large numbers stored as linked lists to avoid integer overflow.

The key insight is to add digits with carry just like manual addition, moving through both lists simultaneously.

Practice

1. What does the problem "Add Two Numbers Represented as Linked List" ask you to do?

easy

A. Add two numbers where each digit is a node in a linked list, and return the sum as a linked list.

B. Multiply two numbers stored in arrays and return the product as an array.

C. Sort two linked lists and merge them into one sorted list.

D. Find the difference between two numbers represented as linked lists.

Solution

1. Step 1: Understand the problem statement

   The problem requires adding two numbers where each number is represented by a linked list. Each node contains a single digit, and digits are stored in reverse order.

2. Step 2: Identify the expected output

   The output should be a linked list representing the sum of the two numbers, also in reverse order.

3. Final Answer:

   Add two numbers represented as linked lists and return their sum as a linked list -> Option A

4. Quick Check:

   Adding digits node by node = Add linked lists [OK]

Hint: Remember digits are reversed in linked lists [OK]

Common Mistakes:

• Thinking digits are stored in normal order
• Confusing addition with multiplication
• Returning a number instead of a linked list

2. Which of the following is the correct way to create a node for a singly linked list in JavaScript for this problem?

easy

A. function ListNode(val) { this.val = val; this.next = null; }

B. class ListNode { constructor(val) { this.value = val; this.nextNode = null; } }

C. let node = { value: val, next: null };

D. function Node(val) { this.val = val; this.nextNode = null; }

Solution

1. Step 1: Check the standard node structure

   The node should have a property named 'val' for the digit and 'next' for the next node pointer.

2. Step 2: Verify the syntax correctness

   function ListNode(val) { this.val = val; this.next = null; } correctly defines a function constructor with 'val' and 'next' properties initialized properly.

3. Final Answer:

   function ListNode(val) { this.val = val; this.next = null; } -> Option A

4. Quick Check:

   Node with val and next properties = function ListNode(val) { this.val = val; this.next = null; } [OK]

Hint: Use 'val' and 'next' for node properties [OK]

Common Mistakes:

• Using 'value' instead of 'val'
• Using 'nextNode' instead of 'next'
• Incorrect constructor syntax

3. What is the output linked list after adding the two numbers represented by these linked lists? List 1: 2 -> 4 -> 3 -> null (represents 342) List 2: 5 -> 6 -> 4 -> null (represents 465)

function addTwoNumbers(l1, l2) {
  let dummy = new ListNode(0);
  let current = dummy;
  let carry = 0;
  while (l1 || l2 || carry) {
    let sum = carry;
    if (l1) { sum += l1.val; l1 = l1.next; }
    if (l2) { sum += l2.val; l2 = l2.next; }
    carry = Math.floor(sum / 10);
    current.next = new ListNode(sum % 10);
    current = current.next;
  }
  return dummy.next;
}

medium

A. 7 -> 0 -> 7 -> null

B. 7 -> 0 -> 8 -> null

C. 7 -> 1 -> 7 -> null

D. 8 -> 0 -> 7 -> null

Solution

1. Step 1: Add digits node by node with carry

   2+5=7 (carry 0), 4+6=10 (carry 1), 3+4+1=8 (carry 0)

2. Step 2: Form the resulting linked list

   The digits are 7 -> 0 -> 8 representing 807 in reverse order.

3. Final Answer:

   7 -> 0 -> 8 -> null -> Option B

4. Quick Check:

   342 + 465 = 807 = 7->0->8 [OK]

Hint: Add digits with carry, build new nodes [OK]

Common Mistakes:

• Ignoring carry after adding digits
• Mixing digit order in output
• Returning sum as a number, not linked list

4. Identify the bug in the following code snippet for adding two numbers represented as linked lists:

function addTwoNumbers(l1, l2) {
  let dummy = new ListNode(0);
  let current = dummy;
  let carry = 0;
  while (l1 !== null && l2 !== null) {
    let sum = carry + l1.val + l2.val;
    carry = Math.floor(sum / 10);
    current.next = new ListNode(sum % 10);
    current = current.next;
    l1 = l1.next;
    l2 = l2.next;
  }
  return dummy.next;
}

medium

A. The function does not return the dummy node itself.

B. The carry is not calculated correctly using Math.floor.

C. The dummy node should be initialized with value 1 instead of 0.

D. The loop condition should use '||' instead of '&&' to handle lists of different lengths.

Solution

1. Step 1: Analyze the loop condition

   The loop stops when either l1 or l2 becomes null, missing remaining nodes if lists differ in length.

2. Step 2: Correct the loop condition

   Using '||' ensures the loop continues until both lists and carry are fully processed.

3. Final Answer:

   The loop condition should use '||' instead of '&&' to handle lists of different lengths. -> Option D

4. Quick Check:

   Loop condition must cover all nodes = The loop condition should use '||' instead of '&&' to handle lists of different lengths. [OK]

Hint: Use '||' to continue while any list or carry remains [OK]

Common Mistakes:

• Stopping loop too early with '&&'
• Ignoring leftover carry after loop
• Not advancing pointers correctly

5. Given two linked lists representing numbers in reverse order, how would you modify the addition function to handle the case where the input lists have different lengths and the final carry creates a new node? Choose the best approach to ensure correct output for inputs like: List 1: 9 -> 9 -> 9 -> null (represents 999) List 2: 1 -> null (represents 1)

function addTwoNumbers(l1, l2) {
  let dummy = new ListNode(0);
  let current = dummy;
  let carry = 0;
  while (l1 || l2 || carry) {
    let sum = carry;
    if (l1) { sum += l1.val; l1 = l1.next; }
    if (l2) { sum += l2.val; l2 = l2.next; }
    carry = Math.floor(sum / 10);
    current.next = new ListNode(sum % 10);
    current = current.next;
  }
  return dummy.next;
}

hard

A. Add zeros to the shorter list before starting the addition to equalize lengths.

B. Stop the loop when both lists end and ignore carry since it won't affect the sum.

C. Use a loop condition that continues while l1, l2, or carry exists, adding carry as a new node if needed.

D. Only add nodes while both lists have nodes, then append the remaining nodes without addition.

Solution

1. Step 1: Understand the need to handle different lengths and carry

   When lists differ in length, addition must continue until both lists and carry are fully processed.

2. Step 2: Use a loop condition that checks l1, l2, or carry

   This ensures the loop adds all digits and creates a new node if carry remains after lists end.

3. Final Answer:

   Use a loop condition that continues while l1, l2, or carry exists, adding carry as a new node if needed. -> Option C

4. Quick Check:

   Loop until all digits and carry processed = Use a loop condition that continues while l1, l2, or carry exists, adding carry as a new node if needed. [OK]

Hint: Loop while any list or carry remains to add all digits [OK]

Common Mistakes:

• Ignoring carry after lists end
• Trying to pad shorter list manually
• Appending leftover nodes without adding carry