Add Two Numbers Represented as Linked List in DSA Typescript

Mental Model

We add two numbers digit by digit like in school, but each digit is a node in a linked list.

Analogy: Imagine adding two numbers written on two separate strings of beads, starting from the rightmost bead and moving left, carrying over when sum exceeds 9.

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

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, carry 1

Result: 7 -> 0 -> null

Why: Sum exceeds 9, carry 1 to next digit

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 Typescript

class ListNode {
  val: number;
  next: ListNode | null;
  constructor(val?: number, next?: ListNode | null) {
    this.val = val === undefined ? 0 : val;
    this.next = next === undefined ? null : next;
  }
}

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

  while (l1 !== null || l2 !== null || carry !== 0) {
    let val1 = l1 !== null ? l1.val : 0;
    let val2 = l2 !== null ? 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 create linked list from array
function createList(arr: number[]): ListNode | null {
  let dummy = new ListNode(0);
  let curr = dummy;
  for (let num of arr) {
    curr.next = new ListNode(num);
    curr = curr.next;
  }
  return dummy.next;
}

// Helper to print linked list
function printList(head: ListNode | null): string {
  let result = '';
  while (head !== null) {
    result += head.val + ' -> ';
    head = head.next;
  }
  return result + 'null';
}

// Driver code
const l1 = createList([2,4,3]);
const l2 = createList([5,6,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 !== null ? l1.val : 0;

get current digit from first list or 0 if none

let val2 = l2 !== null ? l2.val : 0;

get current digit from second list or 0 if none

let sum = val1 + val2 + carry;

add digits plus carry from previous step

carry = Math.floor(sum / 10);

calculate new carry for next digit

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

store current digit in result list

current = current.next;

move pointer forward in result list

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(max(m, n)) because we traverse both lists once where m and n are their lengths

Space: O(max(m, n)) for the new linked list storing the sum digits

vs Alternative: Using arrays and reversing them would add extra O(m + n) time and space for reversal steps

Edge Cases

One list is empty

Returns the other list as sum

DSA Typescript

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

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

Adds an extra node with value 1 at the end

DSA Typescript

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

Lists of different lengths

Continues adding remaining digits of longer list plus carry

DSA Typescript

let val1 = l1 !== null ? l1.val : 0;

When to Use This Pattern

When you see two numbers stored as linked lists with digits in reverse order, use this pattern to add them digit by digit with carry.

Common Mistakes

Mistake: Not handling carry after both lists are fully traversed
Fix: Include carry in while loop condition to add extra node if needed

Mistake: Advancing list pointers without checking for 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 numbers are stored in linked lists with least significant digit first.

The key is to add digits and carry stepwise, creating new nodes for the sum.

Practice

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

easy

A. Find the difference between two numbers stored as strings.

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

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

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

Solution

1. Step 1: Understand the input format

   The numbers are given as linked lists where each node contains a single digit, and digits are stored in reverse order.

2. Step 2: Understand the required output

   You must add these two numbers digit by digit and return the sum as a linked list in the same reversed format.

3. Final Answer:

   Add two numbers digit-wise from linked lists and return sum as linked list -> Option B

4. Quick Check:

   Adding digits node by node = Add two numbers as linked lists [OK]

Hint: Add digits node by node with carry, return linked list [OK]

Common Mistakes:

• Confusing input format as normal integers
• Returning sum as integer instead of linked list
• Ignoring carry over digits

2. Which TypeScript code snippet correctly defines a node for a singly linked list used in this problem?

easy

A. class ListNode { val: number; next: ListNode | null; constructor(val?: number, next?: ListNode | null) { this.val = val ?? 0; this.next = next ?? null; } }

B. interface ListNode { value: string; next: ListNode; }

C. type ListNode = { val: string; next: ListNode | undefined; };

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

Solution

1. Step 1: Check for correct TypeScript class syntax

   class ListNode { val: number; next: ListNode | null; constructor(val?: number, next?: ListNode | null) { this.val = val ?? 0; this.next = next ?? null; } } defines a class with val as number and next as ListNode or null, with a constructor and default values.

2. Step 2: Verify other options

   interface ListNode { value: string; next: ListNode; } uses interface with string type and no null for next, type ListNode = { val: string; next: ListNode | undefined; }; uses string val and next possibly undefined, function ListNode(val) { this.val = val; this.next = null; } is JavaScript function style without types.

3. Final Answer:

   TypeScript class with number val and nullable next -> Option A

4. Quick Check:

   TypeScript class with number val and nullable next = class ListNode { val: number; next: ListNode | null; constructor(val?: number, next?: ListNode | null) { this.val = val ?? 0; this.next = next ?? null; } } [OK]

Hint: Use class with val:number and next: ListNode|null [OK]

Common Mistakes:

• Using string instead of number for val
• Not allowing next to be null
• Using JavaScript function instead of TypeScript class

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) Use the standard addition method for linked lists.

medium

A. 7 -> 10 -> 7 -> null

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

C. 7 -> 0 -> 8 -> null

D. 2 -> 0 -> 8 -> null

Solution

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

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

2. Step 2: Form the resulting linked list

   Digits are 7, 0 (from 10), and 8, so linked list is 7 -> 0 -> 8 -> null

3. Final Answer:

   7 -> 0 -> 8 -> null -> Option C

4. Quick Check:

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

Hint: Add digits with carry, store remainder in node [OK]

Common Mistakes:

• Not carrying over when sum >= 10
• Reversing the order of digits in output
• Adding digits incorrectly without carry

4. Given this TypeScript function to add two numbers as linked lists, what is the bug?

function addTwoNumbers(l1: ListNode | null, l2: ListNode | null): ListNode | null {
  let dummy = new ListNode(0);
  let current = dummy;
  let carry = 0;
  while (l1 !== null && l2 !== null) {
    let sum = l1.val + l2.val + carry;
    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. Carry is not calculated correctly using Math.floor.

B. The function returns dummy instead of dummy.next.

C. Dummy node is not initialized properly.

D. The loop stops when either list ends, missing remaining nodes in longer list.

Solution

1. Step 1: Analyze the while loop condition

   The loop runs only while both l1 and l2 are not null, so it stops if one list is longer.

2. Step 2: Identify missing handling of remaining nodes

   After the loop, remaining nodes of the longer list and any carry are not processed, causing incorrect result.

3. Final Answer:

   Loop stops too early, missing remaining nodes in longer list -> Option D

4. Quick Check:

   Loop condition && misses longer list nodes [OK]

Hint: Use || in loop to handle different length lists [OK]

Common Mistakes:

• Using && instead of || in loop condition
• Not processing leftover carry after loop
• Returning dummy instead of dummy.next

5. You have two linked lists representing numbers: List 1: 9 -> 9 -> 9 -> 9 -> null (9999) and List 2: 1 -> null (1). What is the correct resulting linked list after adding them?

hard

A. 0 -> 0 -> 0 -> 0 -> 1 -> null

B. 1 -> 0 -> 0 -> 0 -> 0 -> null

C. 0 -> 0 -> 0 -> 0 -> null

D. 9 -> 9 -> 9 -> 10 -> null

Solution

1. Step 1: Add digits with carry from right to left

   9+1=10 (0 carry 1), next 9+0+1=10 (0 carry 1), repeat for next two 9s with carry 1.

2. Step 2: Add final carry as new node

   After last 9+0+1=10, carry 1 remains, so add new node with 1 at the end.

3. Final Answer:

   0 -> 0 -> 0 -> 0 -> 1 -> null -> Option A

4. Quick Check:

   9999 + 1 = 10000 as linked list 0->0->0->0->1 [OK]

Hint: Add carry after last node if needed [OK]

Common Mistakes:

• Not adding extra node for final carry
• Stopping addition early when one list ends
• Incorrectly placing carry node position