Traversal and Printing a Linked List in DSA C# - 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 printed in order.

🎯 Goal: Build a linked list with three contacts, then write code to go through the list and print each contact's name in order.

📋 What You'll Learn

Create a linked list node class called Node with a string Name and a Node Next property

Create three nodes with names exactly "Alice", "Bob", and "Charlie"

Link the nodes so that Alice points to Bob, and Bob points to Charlie

Use a Node variable called head to hold the start of the list

Write a while loop to traverse the list starting from head

Print each node's Name followed by " -> " except the last node which ends with "null"

💡 Why This Matters

🌍 Real World

Linked lists are used in many apps to store ordered data where items can be added or removed easily, like contact lists or playlists.

💼 Career

Understanding linked lists is fundamental for software developers, especially when working with low-level data structures or preparing for coding interviews.

1

Create the Node class and three nodes

Create a class called Node with a string Name and a Node Next property. Then create three Node objects named node1, node2, and node3 with names exactly "Alice", "Bob", and "Charlie" respectively.

DSA C#

// Define the Node class and create three nodes
// Your code here

Hint

Start by defining the Node class with the two properties. Then create three nodes using the constructor.

2

Link the nodes and set the head

Link the nodes so that node1.Next points to node2, and node2.Next points to node3. Then create a Node variable called head and set it to node1.

DSA C#

public class Node
{
    public string Name;
    public Node Next;

    public Node(string name)
    {
        Name = name;
        Next = null;
    }
}

Node node1 = new Node("Alice");
Node node2 = new Node("Bob");
Node node3 = new Node("Charlie");

// Link the nodes and set head
// Your code here

Hint

Set the Next property of each node to link them. Then assign head to the first node.

3

Traverse the linked list

Create a Node variable called current and set it to head. Use a while loop that runs while current is not null. Inside the loop, print the current.Name followed by " -> " if current.Next is not null, otherwise print "null". Then move current to current.Next.

DSA C#

public class Node
{
    public string Name;
    public Node Next;

    public Node(string name)
    {
        Name = name;
        Next = null;
    }
}

Node node1 = new Node("Alice");
Node node2 = new Node("Bob");
Node node3 = new Node("Charlie");

node1.Next = node2;
node2.Next = node3;
Node head = node1;

// Traverse the list and print names
// Your code here

Hint

Use a while loop to go through each node. Print the name and arrow, or "null" if it's the last node.

4

Print the linked list

Run the program to print the linked list. The output should show the names connected by arrows and end with "null".

DSA C#

public class Node
{
    public string Name;
    public Node Next;

    public Node(string name)
    {
        Name = name;
        Next = null;
    }
}

Node node1 = new Node("Alice");
Node node2 = new Node("Bob");
Node node3 = new Node("Charlie");

node1.Next = node2;
node2.Next = node3;
Node head = node1;

Node current = head;
while (current != null)
{
    if (current.Next != null)
        System.Console.Write(current.Name + " -> ");
    else
        System.Console.Write(current.Name + " -> null");
    current = current.Next;
}

// Run the program to see the output
// Your code here

Hint

Run the program and check the console output matches exactly.

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