Traversal and Printing a Linked List in DSA Typescript - Build from Scratch

Traversal and Printing a Linked List

📖 Scenario: You are working on a simple contact list app. Each contact is stored as a node in a linked list. You want to see all contacts by traversing the list and printing their names.

🎯 Goal: Build a linked list with 3 contacts, traverse it, and print all contact names in order.

📋 What You'll Learn

Create a linked list node class called ListNode with name and next properties

Create a linked list with exactly 3 nodes with names: 'Alice', 'Bob', 'Charlie'

Create a variable called head pointing to the first node

Traverse the linked list using a while loop and print each name

Print the names in the format: Alice -> Bob -> Charlie -> null

💡 Why This Matters

🌍 Real World

Linked lists are used in many apps to store ordered data where you want to add or remove items easily, like playlists, contact lists, or undo history.

💼 Career

Understanding linked lists helps in technical interviews and is a foundation for learning more complex data structures used in software development.

1

Create the linked list nodes

Create a class called ListNode with a constructor that takes a name string and sets this.name. Also add a next property initialized to null. Then create three nodes called node1, node2, and node3 with names 'Alice', 'Bob', and 'Charlie' respectively.

DSA Typescript

// Your code here

Hint

Define the class with name and next. Then create three nodes with the exact names.

2

Link the nodes and create the head

Link node1 to node2 by setting node1.next = node2. Link node2 to node3 by setting node2.next = node3. Create a variable called head and set it to node1.

DSA Typescript

class ListNode {
    name: string;
    next: ListNode | null;
    constructor(name: string) {
        this.name = name;
        this.next = null;
    }
}

const node1 = new ListNode('Alice');
const node2 = new ListNode('Bob');
const node3 = new ListNode('Charlie');

// Your code here

Hint

Set the next property of each node to link them. Then set head to the first node.

3

Traverse the linked list

Create a variable called current and set it to head. Use a while loop that runs while current is not null. Inside the loop, print current.name followed by ' -> ' without a newline. Then update current to current.next.

DSA Typescript

class ListNode {
    name: string;
    next: ListNode | null;
    constructor(name: string) {
        this.name = name;
        this.next = null;
    }
}

const node1 = new ListNode('Alice');
const node2 = new ListNode('Bob');
const node3 = new ListNode('Charlie');

node1.next = node2;
node2.next = node3;

const head = node1;

// Your code here

Hint

Use process.stdout.write to print without a newline. Move current to the next node each time.

4

Print the end of the list

After the while loop, print 'null' to show the end of the linked list.

DSA Typescript

class ListNode {
    name: string;
    next: ListNode | null;
    constructor(name: string) {
        this.name = name;
        this.next = null;
    }
}

const node1 = new ListNode('Alice');
const node2 = new ListNode('Bob');
const node3 = new ListNode('Charlie');

node1.next = node2;
node2.next = node3;

const head = node1;

let current = head;
while (current !== null) {
    process.stdout.write(current.name + ' -> ');
    current = current.next;
}

// Your code here

Hint

Use console.log('null') to print the end with a newline.

Practice

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

easy

A. Visit each node in the list one by one from start to end

B. Add a new node at the end of the list

C. Delete the first node of the list

D. Reverse the order of nodes in the list

Solution

1. Step 1: Understand traversal meaning

   Traversal means going through each element in order to access or process it.

2. Step 2: Apply to linked list context

   In a linked list, traversal means visiting each node starting from the head until the end (null).

3. Final Answer:

   Visit each node in the list one by one from start to end -> Option A

4. Quick Check:

   Traversal = Visit nodes sequentially [OK]

Hint: Traversal means visiting nodes one after another [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 linked list in TypeScript?

easy

A. let current = head;

B. let current = tail;

C. let current = null;

D. let current = new Node();

Solution

1. Step 1: Identify starting point for traversal

   Traversal starts from the first node, called head, to visit all nodes.

2. Step 2: Check options for correct initialization

   Setting current to head allows moving through nodes; tail or null won't start traversal properly.

3. Final Answer:

   let current = head; -> Option A

4. Quick Check:

   Start traversal at head node [OK]

Hint: Always start traversal from the head node [OK]

Common Mistakes:

• Starting traversal from tail which is the last node
• Initializing current to null which skips traversal
• Creating a new node instead of using existing head

3. What will be the output of the following TypeScript code that prints a linked list?

class Node {
  value: number;
  next: Node | null;
  constructor(value: number) {
    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;
while (current !== null) {
  console.log(current.value);
  current = current.next;
}

medium

A. 3 2 1

B. 1 2 3

C. 1 3 2

D. 2 3 1

Solution

1. Step 1: Understand list structure

   The list nodes are linked as 1 -> 2 -> 3 -> null.

2. Step 2: Trace the while loop output

   The loop prints current.value starting at head (1), then moves to 2, then 3, then stops at null.

3. Final Answer:

   1 2 3 -> Option B

4. Quick Check:

   Print nodes in order: 1 2 3 [OK]

Hint: Print values while moving from head to next until null [OK]

Common Mistakes:

• Printing in reverse order by mistake
• Skipping nodes by incorrect pointer update
• Confusing node values order

4. Identify the error in this linked list traversal code and select the fix:

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

medium

A. Remove console.log inside the loop

B. Add console.log after the loop

C. Initialize current to null

D. Change condition to current !== null

Solution

1. Step 1: Analyze loop condition

   The loop stops when current.next is null, so it skips printing the last node.

2. Step 2: Fix condition to include last node

   Changing condition to current !== null ensures all nodes, including last, are printed.

3. Final Answer:

   Change condition to current !== null -> Option D

4. Quick Check:

   Loop until current is null to print all nodes [OK]

Hint: Loop until current is null to include last node [OK]

Common Mistakes:

• Using current.next !== null misses last node
• Not updating current inside loop causes infinite loop
• Printing after loop instead of inside

5. Given a linked list with nodes containing values 5 -> 10 -> 15 -> null, write a TypeScript function to traverse and collect these values into an array. What will be the returned array after traversal?

hard

A. [15, 10, 5]

B. [5, 15, 10]

C. [5, 10, 15]

D. [10, 5, 15]

Solution

1. Step 1: Traverse from head to end

   Start at head (5), then move to 10, then 15, collecting values in order.

2. Step 2: Collect values in array during traversal

   Push each node's value into an array as you visit it, resulting in [5, 10, 15].

3. Final Answer:

   [5, 10, 15] -> Option C

4. Quick Check:

   Values collected in order visited [OK]

Hint: Collect values while traversing from head to null [OK]

Common Mistakes:

• Collecting values in reverse order
• Skipping nodes by wrong pointer update
• Returning array before traversal completes