Traversal and Printing a Linked List in DSA Javascript

Mental Model

Go through each item in the list one by one from start to end and show its value.

Analogy: Like reading a line of people holding hands, you look at each person in order from the first to the last.

head -> 1 -> 2 -> 3 -> null
          ↑

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3, print all values

Goal: Print all values in the list in order, separated by arrows, ending with null.

Step 1: start at head node with value 1

head -> [curr->1] -> 2 -> 3 -> null

Why: We begin printing from the first node.

Step 2: print 1 and move curr to next node

head -> 1 -> [curr->2] -> 3 -> null

Why: After printing current value, move to next node to continue.

Step 3: print 2 and move curr to next node

head -> 1 -> 2 -> [curr->3] -> null

Why: Continue printing values in order.

Step 4: print 3 and move curr to next node

head -> 1 -> 2 -> 3 -> [curr->null]

Why: Last node printed, move to null to end.

Step 5: curr is null, stop printing and print null

head -> 1 -> 2 -> 3 -> null

Why: Reached end of list, printing complete.

Result:

1 -> 2 -> 3 -> null

Annotated Code

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
  }

  // Add nodes for testing
  append(value) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      return;
    }
    let curr = this.head;
    while (curr.next) {
      curr = curr.next;
    }
    curr.next = newNode;
  }

  // Traverse and print the list
  printList() {
    let curr = this.head; // start at head
    let output = '';
    while (curr) { // while current node exists
      output += curr.value + ' -> ';
      curr = curr.next; // move to next node
    }
    output += 'null'; // end of list
    console.log(output);
  }
}

// Driver code
const list = new LinkedList();
list.append(1);
list.append(2);
list.append(3);
list.printList();

let curr = this.head; // start at head

initialize current pointer to head to start traversal

while (curr) {

continue loop while current node is not null

output += curr.value + ' -> ';

append current node's value to output string

curr = curr.next; // move to next node

advance current pointer to next node

output += 'null';

append 'null' to mark end of list

Output

1 -> 2 -> 3 -> null

Complexity Analysis

Time: O(n) because we visit each of the n nodes once to print their values

Space: O(n) because the output string grows with the number of nodes

vs Alternative: Compared to recursive printing which uses extra call stack space, this iterative approach uses constant extra space besides output

Edge Cases

empty list

prints 'null' immediately since head is null

DSA Javascript

while (curr) {

single node list

prints the single value followed by 'null'

DSA Javascript

while (curr) {

When to Use This Pattern

When you need to show or process every item in a linked list in order, use traversal by moving from head to next nodes until null.

Common Mistakes

Mistake: Forgetting to move the current pointer to the next node inside the loop
Fix: Add 'curr = curr.next;' inside the while loop to advance traversal

Mistake: Printing 'null' before finishing the list or missing it entirely
Fix: Append 'null' after the loop to clearly mark the end of the list

Summary

It goes through each node in the linked list and prints its value in order.

Use it when you want to see or use all values stored in a linked list.

Remember to move from one node to the next until you reach the end (null).

Practice

1. What does it mean to traverse a linked list?

easy

A. To add a new node at the end of the list

B. To delete the first node of the list

C. To visit each node in the list one by one from start to end

D. To reverse the order of nodes in the list

Solution

1. Step 1: Understand traversal meaning

   Traversal means going through each element in a data structure in order.

2. Step 2: Apply to linked list

   For a linked list, traversal means visiting each node from the first to the last.

3. Final Answer:

   To visit each node in the list one by one from start to end -> Option C

4. Quick Check:

   Traversal = Visit nodes in order [OK]

Hint: Traversal means visiting nodes one by one [OK]

Common Mistakes:

• Confusing traversal with insertion or deletion
• Thinking traversal changes the list order
• Assuming traversal skips nodes

2. Which of the following is the correct way to start traversing a singly linked list in JavaScript?

easy

A. let current = head;

B. let current = tail;

C. let current = null;

D. let current = head.next.next;

Solution

1. Step 1: Identify the start of the list

   The traversal starts from the first node, called head.

2. Step 2: Assign current pointer

   Setting current = head means we start visiting from the first node.

3. Final Answer:

   let current = head; -> Option A

4. Quick Check:

   Start traversal at head [OK]

Hint: Traversal always starts at head node [OK]

Common Mistakes:

• Starting at tail which is the last node
• Starting at null which means no node
• Skipping nodes by starting at head.next.next

3. What will be the output of the following code snippet?

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

const head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);

let current = head;
let result = '';
while (current !== null) {
  result += current.value + ' -> ';
  current = current.next;
}
result += 'null';
console.log(result);

medium

A. null -> 1 -> 2 -> 3

B. 1 -> 2 -> 3 -> null

C. 1 -> 2 -> 3

D. 3 -> 2 -> 1 -> null

Solution

1. Step 1: Trace the linked list nodes

   The list has nodes with values 1, 2, and 3 linked in order.

2. Step 2: Follow the while loop

   The loop appends each node's value followed by ' -> ' until current is null, then adds 'null'.

3. Final Answer:

   1 -> 2 -> 3 -> null -> Option B

4. Quick Check:

   Print nodes in order with arrow and null [OK]

Hint: Follow each node and append value with arrow [OK]

Common Mistakes:

• Forgetting to add 'null' at the end
• Printing nodes in reverse order
• Missing arrows between nodes

4. The following code is intended to print all values in a linked list. What is the error?

let current = head;
while (current.next !== null) {
  console.log(current.value);
  current = current.next;
}

medium

A. It will print undefined values

B. It will cause an infinite loop

C. It will throw a syntax error

D. It will skip printing the last node's value

Solution

1. Step 1: Analyze the loop condition

   The loop runs while current.next is not null, so it stops before last node.

2. Step 2: Check which nodes get printed

   It prints current.value inside loop, so last node (where current.next is null) is not printed.

3. Final Answer:

   It will skip printing the last node's value -> Option D

4. Quick Check:

   Loop condition excludes last node [OK]

Hint: Use current !== null to include last node [OK]

Common Mistakes:

• Using current.next !== null instead of current !== null
• Assuming last node is printed
• Confusing loop condition with syntax error

5. You want to print a linked list in reverse order without modifying the list or using extra arrays. Which approach is best?

hard

A. Use recursion to traverse to the end, then print on return

B. Traverse normally and print values as you go

C. Reverse the list first, then print

D. Use a loop with current.next !== null condition

Solution

1. Step 1: Understand the problem constraints

   We cannot modify the list or use extra arrays, so reversing or storing values is not allowed.

2. Step 2: Use recursion to print in reverse

   Recursion goes to the end of the list, then prints values on the way back, achieving reverse order without extra storage.

3. Final Answer:

   Use recursion to traverse to the end, then print on return -> Option A

4. Quick Check:

   Recursion prints reverse without extra space [OK]

Hint: Recursion prints reverse by returning from end [OK]

Common Mistakes:

• Trying to reverse list which modifies it
• Using loops that print forward only
• Using extra arrays which is disallowed