Add Two Numbers Represented as Linked List in DSA Javascript - Execution Trace

Concept Flow - Add Two Numbers Represented as Linked List

Start with two linked lists

↓

Initialize carry = 0 and dummy head

↓

Traverse both lists node by node

↓

Add node values + carry

↓

Calculate new digit and update carry

↓

Create new node with digit, attach to result

↓

Move to next nodes in both lists

↓

Repeat until both lists and carry are empty

↓

Return result list starting after dummy head

We add digits from two linked lists node by node, keep track of carry, create new nodes for sum digits, and continue until all digits and carry are processed.

Execution Sample

DSA Javascript

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

This code adds two numbers represented by linked lists digit by digit, handling carry, and returns the sum as a new linked list.

Execution Table

Step	Operation	l1 Node Value	l2 Node Value	Sum	Carry	New Node Value	Result List Visual
1	Add first nodes	2	5	7	0	7	7 -> null
2	Add second nodes	4	6	10	1	0	7 -> 0 -> null
3	Add third nodes	3	4	8 (3+4+1)	0	8	7 -> 0 -> 8 -> null
4	No more nodes, carry 0	null	null	0	0	none	7 -> 0 -> 8 -> null

💡 Both lists are fully traversed and carry is 0, so addition stops.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
l1	2 -> 4 -> 3 -> null	4 -> 3 -> null	3 -> null	null	null
l2	5 -> 6 -> 4 -> null	6 -> 4 -> null	4 -> null	null	null
carry	0	0	1	0	0
current (result tail)	dummy	7	0	8	8
Result List	empty	7 -> null	7 -> 0 -> null	7 -> 0 -> 8 -> null	7 -> 0 -> 8 -> null

Key Moments - 3 Insights

Why do we continue the loop when both lists are null but carry is not zero?

Because carry can add an extra digit to the result. For example, if sum is 10, carry becomes 1 and must be added as a new node. This is shown in Step 2 where carry becomes 1 and affects Step 3.

Why do we use a dummy head node for the result list?

The dummy head simplifies adding new nodes without checking if the list is empty. It holds a placeholder before the actual result starts, as seen in the variable_tracker where current starts at dummy.

How do we handle different lengths of the two input lists?

We treat missing nodes as zero by using (l1 ? l1.val : 0) and (l2 ? l2.val : 0). This allows addition to continue smoothly even if one list is shorter.

Visual Quiz - 3 Questions

Look at the execution table, what is the carry value after Step 2?

A 0

B 1

C 2

D None

💡 Hint

Check the 'Carry' column in the execution_table row for Step 2.

At which step does the result list first contain three nodes?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Result List Visual' column to see when three nodes appear.

If the first list was longer by one node with value 1, how would the carry behave at the last step?

A Carry would be 0 and an extra node added

B Carry would be 1 and an extra node added

C Carry would be 2 and two extra nodes added

D Carry would be ignored

💡 Hint

Consider how carry is calculated and when the loop stops in the execution_table and variable_tracker.

Concept Snapshot

Add Two Numbers as Linked Lists:
- Traverse both lists node by node
- Sum digits + carry
- Create new node with sum % 10
- Update carry = sum // 10
- Continue until lists and carry are empty
- Use dummy head to simplify list building

Full Transcript

This concept shows how to add two numbers represented by linked lists. We start with two lists, each node holding a digit. We add corresponding digits plus any carry from previous addition. The sum's last digit becomes a new node in the result list, and the carry is updated for the next step. We continue until both lists are fully processed and no carry remains. A dummy head node helps build the result list easily. The execution table tracks each addition step, showing node values, sums, carry, and the growing result list. Variable tracking shows how pointers and carry change after each step. Key moments clarify why carry must be handled after lists end, why dummy head is used, and how different list lengths are managed. The visual quiz tests understanding of carry values, result list growth, and carry behavior with longer lists.

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