Traversal and Printing a Linked List in DSA C# - Execution Trace

Concept Flow - Traversal and Printing a Linked List

Start at head node

↓

Is current node null?

Yes→Stop traversal

No↓

Print current node data

↓

Move to next node

↩Back to check current node

Start from the head node, check if current node exists, print its data, then move to the next node until the end.

Execution Sample

DSA C#

Node current = head;
while (current != null) {
    Console.Write(current.data + " -> ");
    current = current.next;
}
Console.WriteLine("null");

This code walks through each node in the linked list from head to end, printing the data followed by an arrow, ending with null.

Execution Table

Step	Operation	Current Node Data	Pointer Changes	Visual State
1	Start traversal at head	1	current = head (node with data 1)	1 -> 2 -> 3 -> null
2	Print current node data	1	No pointer change	1 -> 2 -> 3 -> null
3	Move to next node	2	current = current.next (node with data 2)	1 -> 2 -> 3 -> null
4	Print current node data	2	No pointer change	1 -> 2 -> 3 -> null
5	Move to next node	3	current = current.next (node with data 3)	1 -> 2 -> 3 -> null
6	Print current node data	3	No pointer change	1 -> 2 -> 3 -> null
7	Move to next node	null	current = current.next (null)	1 -> 2 -> 3 -> null
8	Check current node	null	Traversal ends	1 -> 2 -> 3 -> null

💡 Traversal stops when current node is null, meaning end of list reached.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 7	Final
current	head (node 1)	node 2	node 3	null	null

Key Moments - 3 Insights

Why do we check if current node is null before printing?

Because if current is null, it means we reached the end of the list and there is no data to print. This is shown in execution_table step 8 where traversal stops.

Why do we move current to current.next after printing?

To move forward in the list to the next node. Without this, we would print the same node repeatedly. See steps 3, 5, and 7 in execution_table.

What does the visual state '1 -> 2 -> 3 -> null' represent?

It shows the linked list nodes in order with arrows pointing to the next node, ending with null to indicate the list end. This state remains constant during traversal.

Visual Quiz - 3 Questions

Look at the execution_table at step 5, what is the current node data?

A 3

B 2

C 1

D null

💡 Hint

Check the 'Current Node Data' column at step 5 in execution_table.

At which step does the traversal stop because current node is null?

A Step 8

B Step 7

C Step 6

D Step 5

💡 Hint

Look at the 'Operation' and 'Pointer Changes' columns in execution_table to find when current becomes null and traversal ends.

If we forget to move current to current.next, what happens in the traversal?

A Traversal ends immediately

B Null pointer exception occurs

C Same node data prints repeatedly

D List prints in reverse order

💡 Hint

Refer to key_moments about pointer movement and execution_table steps 3, 5, 7.

Concept Snapshot

Traversal and Printing a Linked List:
- Start at head node
- While current node is not null:
  - Print current node data
  - Move to next node
- End when current is null
- Prints nodes in order ending with null

Full Transcript

Traversal of a linked list means starting at the head node and moving through each node one by one until the end. We check if the current node is null to know when to stop. At each node, we print its data and then move the pointer to the next node. This process repeats until the pointer reaches null, which means the list has ended. The visual state of the list remains the same during traversal, showing nodes connected by arrows ending with null.

Practice

1. What does traversing a linked list mean in simple terms?

easy

A. Reversing the order of nodes

B. Visiting each node one by one from start to end

C. Deleting the first node

D. Adding a new node at the end

Solution

1. Step 1: Understand traversal

   Traversal means going through each node in the linked list starting from the first node.

2. Step 2: Identify what happens during traversal

   We visit each node one by one until we reach the end (null).

3. Final Answer:

   Visiting each node one by one from start to end -> Option B

4. Quick Check:

   Traversal = Visit nodes sequentially [OK]

Hint: Traversal means visiting nodes one after another [OK]

Common Mistakes:

• Confusing traversal with adding or deleting nodes
• Thinking traversal changes the list order
• Assuming traversal skips nodes

2. Which of the following is the correct C# syntax to start traversing a singly linked list named head?

easy

A. Node current => head;

B. Node current == head;

C. Node current = head;

D. Node current <- head;

Solution

1. Step 1: Check variable assignment syntax in C#

   In C#, to assign a value, use a single equals sign (=), not double (==) or arrows.

2. Step 2: Identify correct assignment for traversal start

   We assign the head node to a variable to start traversal: Node current = head;

3. Final Answer:

   Node current = head; -> Option C

4. Quick Check:

   Assignment uses =, not == or arrows [OK]

Hint: Use single = for assignment in C# [OK]

Common Mistakes:

• Using == instead of = for assignment
• Using arrow symbols which are invalid
• Confusing assignment with comparison

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

class Node {
  public int data;
  public Node next;
  public Node(int d) { data = d; next = null; }
}

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

Node current = head;
while (current != null) {
  Console.Write(current.data + " -> ");
  current = current.next;
}
Console.WriteLine("null");

medium

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

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

C. 3 -> 2 -> 1 -> null

D. 1 2 3 null

Solution

1. Step 1: Understand the linked list structure

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

2. Step 2: Trace the while loop output

   The loop prints each node's data followed by ' -> ', then moves to next node until null.

3. Final Answer:

   1 -> 2 -> 3 -> null -> Option A

4. Quick Check:

   Print nodes in order with arrows and end with null [OK]

Hint: Print nodes in order, end with null [OK]

Common Mistakes:

• Printing nodes in reverse order
• Missing arrows or null in output
• Printing null at start instead of end

4. Identify the error in this linked list traversal code snippet:

Node current = head;
while (current.next != null) {
  Console.Write(current.data + " -> ");
  current = current.next;
}
Console.WriteLine("null");

medium

A. It prints nodes in reverse order

B. It causes a null reference exception

C. It never enters the loop

D. It skips printing the last node's data

Solution

1. Step 1: Analyze the loop condition

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

2. Step 2: Check what gets printed

   Since the last node's data is printed only inside the loop, it is skipped.

3. Final Answer:

   It skips printing the last node's data -> 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 prints automatically
• Confusing loop condition with node data access

5. Given a singly linked list, how would you modify the traversal code to print the list in reverse order without changing the list structure?

hard

A. Use recursion to print nodes after recursive call returns

B. Traverse normally and print nodes immediately

C. Reverse the list first then print

D. Use a for loop with index to print backwards

Solution

1. Step 1: Understand the problem constraints

   We cannot change the list structure, so reversing the list is not allowed.

2. Step 2: Use recursion to print in reverse

   Recursion visits nodes forward, then prints after returning, effectively printing backwards.

3. Final Answer:

   Use recursion to print nodes after recursive call returns -> Option A

4. Quick Check:

   Recursion prints in reverse without modifying list [OK]

Hint: Recursion prints reverse by printing after calls return [OK]

Common Mistakes:

• Trying to use index-based loops on linked list
• Reversing list which changes structure
• Printing nodes immediately during traversal