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

Traversal and Printing a Linked List

📖 Scenario: Imagine you have a chain of boxes, each holding a number and a link to the next box. This is like a linked list. You want to look inside each box and see the numbers in order.

🎯 Goal: You will create a simple linked list with three nodes, then write code to go through the list from start to end and print all the numbers in order.

📋 What You'll Learn

Create a linked list node structure with an integer value and a pointer to the next node

Create three linked list nodes with values 10, 20, and 30

Link the nodes together to form a list: 10 -> 20 -> 30

Write a loop to traverse the linked list starting from the head node

Print the values of each node in the format: 10 -> 20 -> 30 -> null

💡 Why This Matters

🌍 Real World

Linked lists are used in many programs to store data that can grow or shrink dynamically, like playlists, undo history, or navigation paths.

💼 Career

Understanding linked lists is fundamental for software developers, especially when working with low-level data structures, memory management, or building efficient algorithms.

1

Create the linked list nodes

Create a struct called Node with an int data and a Node* next. Then create three Node objects named node1, node2, and node3 with data values 10, 20, and 30 respectively.

DSA C++

// Define the Node struct and create node1, node2, node3 with data 10, 20, 30
// Your code here

Hint

Define the struct with two members: int data and Node* next. Then create three nodes with the given values and set their next pointers to nullptr.

2

Link the nodes to form the list

Link the nodes by setting node1.next to &node2 and node2.next to &node3. Leave node3.next as nullptr. Also create a Node* pointer called head that points to &node1.

DSA C++

struct Node {
    int data;
    Node* next;
};

Node node1 = {10, nullptr};
Node node2 = {20, nullptr};
Node node3 = {30, nullptr};

// Link node1 to node2 and node2 to node3
// Create a pointer head to node1
// Your code here

Hint

Set the next pointers to link the nodes in order. Then create a pointer head to the first node.

3

Traverse the linked list

Write a Node* pointer called current and set it to head. Then write a while loop that runs while current != nullptr. Inside the loop, print the data of current followed by " -> ", then move current to current->next.

DSA C++

struct Node {
    int data;
    Node* next;
};

Node node1 = {10, nullptr};
Node node2 = {20, nullptr};
Node node3 = {30, nullptr};

node1.next = &node2;
node2.next = &node3;
Node* head = &node1;

// Traverse the list using current pointer and print data with arrows
// Your code here

Hint

Use a pointer current to move through the list. Print each node's data followed by an arrow, then go to the next node.

4

Print the end of the list

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

DSA C++

#include 

struct Node {
    int data;
    Node* next;
};

Node node1 = {10, nullptr};
Node node2 = {20, nullptr};
Node node3 = {30, nullptr};

node1.next = &node2;
node2.next = &node3;
Node* head = &node1;

Node* current = head;
while (current != nullptr) {
    std::cout data  ";
    current = current->next;
}

// Print "null" after the loop
// Your code here

Hint

After the loop finishes, print "null" to show the list ends here.

Practice

1. What is the main purpose of traversing a linked list in data structures?

easy

A. To delete all nodes at once

B. To reverse the linked list automatically

C. To create a new linked list

D. To visit each node and access its data

Solution

1. Step 1: Understand traversal meaning

   Traversal means visiting each node one by one in the linked list.

2. Step 2: Purpose of traversal

   The main goal is to access or process the data stored in each node during the visit.

3. Final Answer:

   To visit each node and access its data -> Option D

4. Quick Check:

   Traversal = Visit nodes [OK]

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

Common Mistakes:

• Confusing traversal with deletion
• Thinking traversal creates new lists
• Assuming traversal reverses the list

2. Which of the following is the correct syntax to start traversing a singly linked list in C++ if head is the pointer to the first node?

easy

A. Node* current = head;

B. Node current = head;

C. Node* current = &head;

D. Node current = *head;

Solution

1. Step 1: Understand pointer usage

   In C++, linked list nodes are accessed via pointers. head is a pointer to the first node.

2. Step 2: Correct pointer assignment

   To traverse, we create a pointer current and assign it to head directly: Node* current = head;

3. Final Answer:

   Node* current = head; -> Option A

4. Quick Check:

   Use pointer to start traversal [OK]

Hint: Use pointer assignment to start traversal [OK]

Common Mistakes:

• Using object instead of pointer
• Taking address of head incorrectly
• Dereferencing head wrongly

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

struct Node {
  int data;
  Node* next;
};

int main() {
  Node n3 = {3, nullptr};
  Node n2 = {2, &n3};
  Node n1 = {1, &n2};
  Node* head = &n1;

  Node* current = head;
  while (current != nullptr) {
    std::cout << current->data << " -> ";
    current = current->next;
  }
  std::cout << "null" << std::endl;
  return 0;
}

medium

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

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

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

D. 1 2 3 null

Solution

1. Step 1: Trace node connections

   Node n1 points to n2, n2 points to n3, n3 points to nullptr (end).

2. Step 2: Follow the while loop output

   The loop prints data of current node then moves to next. So prints 1, then 2, then 3, then stops.

3. Final Answer:

   1 -> 2 -> 3 -> null -> Option C

4. Quick Check:

   Print nodes in order from head [OK]

Hint: Follow next pointers from head until nullptr [OK]

Common Mistakes:

• Printing nodes in reverse order
• Missing '->' arrows in output
• Not printing 'null' at the end

4. Identify the error in the following code snippet that attempts to print a linked list:

struct Node {
  int data;
  Node* next;
};

void printList(Node* head) {
  Node* current = head;
  while (current->next != nullptr) {
    std::cout << current->data << " -> ";
    current = current->next;
  }
  std::cout << "null" << std::endl;
}

medium

A. The loop condition should be current != nullptr, not current->next != nullptr

B. The print statement should be after the loop

C. The function should return an int

D. The pointer current should be declared as Node current, not Node* current

Solution

1. Step 1: Analyze loop condition

   The loop stops when current->next is nullptr, so it skips printing the last node's data.

2. Step 2: Correct loop condition

   It should check current != nullptr to print all nodes including the last one.

3. Final Answer:

   The loop condition should be current != nullptr, not current->next != nullptr -> Option A

4. Quick Check:

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

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

Common Mistakes:

• Stopping loop too early missing last node
• Wrong pointer type declaration
• Misplacing print statement

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 or using recursion?

hard

A. Traverse normally and print nodes as you go

B. Use a stack to store nodes during traversal, then pop and print

C. Reverse the list first, then print

D. Use two pointers to print backwards

Solution

1. Step 1: Understand constraints

   We cannot change the list or use recursion, so reversing pointers or recursive calls are not allowed.

2. Step 2: Use auxiliary data structure

   Use a stack to push each node's data during traversal, then pop from stack to print in reverse order.

3. Final Answer:

   Use a stack to store nodes during traversal, then pop and print -> Option B

4. Quick Check:

   Stack reverses order without modifying list [OK]

Hint: Use stack to reverse print without changing list [OK]

Common Mistakes:

• Trying to reverse list pointers directly
• Using recursion despite restriction
• Assuming two pointers can print backwards