Traversal Forward and Backward in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to print all elements of a doubly linked list in forward direction.

DSA C++

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

Drag options to blanks, or click blank then click option'

Ahead

Bnullptr

Ccurrent

DNULL

Attempts:

3 left

💡 Hint

Common Mistakes

Using head instead of nullptr in the loop condition.

The loop continues until current becomes nullptr, which means the end of the list.

2fill in blank

medium

Complete the code to print all elements of a doubly linked list in backward direction starting from tail.

DSA C++

void printBackward(Node* tail) {
    Node* current = tail;
    while (current != [1]) {
        std::cout << current->data << " -> ";
        current = current->prev;
    }
    std::cout << "null" << std::endl;
}

Drag options to blanks, or click blank then click option'

Ahead

Btail

Cnullptr

Dcurrent

Attempts:

3 left

💡 Hint

Common Mistakes

Using tail instead of nullptr in the loop condition.

The loop stops when current becomes nullptr, indicating the start of the list has been passed.

3fill in blank

hard

Fix the error in the code to traverse forward correctly.

DSA C++

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

Drag options to blanks, or click blank then click option'

Aprev

Bhead

Ctail

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev pointer when moving forward.

To move forward in a doubly linked list, use the next pointer.

4fill in blank

hard

Fill both blanks to traverse backward and print data.

DSA C++

void traverseBackward(Node* tail) {
    Node* current = tail;
    while (current != [1]) {
        std::cout << current->[2] << " -> ";
        current = current->prev;
    }
    std::cout << "null" << std::endl;
}

Drag options to blanks, or click blank then click option'

Anullptr

Bhead

Cdata

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Using head instead of nullptr in loop condition.

Printing next instead of data.

The loop ends when current is nullptr. To print the node's value, use the data field.

5fill in blank

hard

Fill all three blanks to create a forward traversal that prints uppercase data assuming data is a char.

DSA C++

void traverseForwardUpper(Node* head) {
    Node* current = head;
    while (current != [1]) {
        std::cout << (char)toupper(current->[2]) << " -> ";
        current = current->[3];
    }
    std::cout << "null" << std::endl;
}

Drag options to blanks, or click blank then click option'

Anullptr

Bdata

Cnext

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev pointer for forward traversal.

Printing pointer instead of data.

Traversal ends at nullptr, print the data field in uppercase, move forward using next pointer.

Practice

1. What does forward traversal mean in the context of a singly linked list?

easy

A. Visiting nodes from the head to the tail in order

B. Visiting nodes from the tail to the head in reverse order

C. Skipping every other node while visiting

D. Visiting nodes randomly without order

Solution

1. Step 1: Understand singly linked list structure

   A singly linked list has nodes connected only forward, from head to tail.

2. Step 2: Define forward traversal

   Forward traversal means visiting nodes starting at the head and moving to the tail in order.

3. Final Answer:

   Visiting nodes from the head to the tail in order -> Option A

4. Quick Check:

   Forward traversal = head to tail [OK]

Hint: Forward means start at head and go next nodes [OK]

Common Mistakes:

• Confusing forward with backward traversal
• Thinking traversal can skip nodes
• Assuming random order traversal

2. Which of the following is the correct syntax to traverse a vector forward in C++?

easy

A. for (int i = 0; i < vec.size(); i++) { cout << vec[i] << ' '; }

B. for (int i = vec.size(); i >= 0; i--) { cout << vec[i] << ' '; }

C. for (int i = 1; i <= vec.size(); i++) { cout << vec[i] << ' '; }

D. for (int i = vec.size() - 1; i > 0; i--) { cout << vec[i] << ' '; }

Solution

1. Step 1: Understand vector indexing in C++

   Vectors are zero-indexed, so valid indices are 0 to size()-1.

2. Step 2: Check loop boundaries

   for (int i = 0; i < vec.size(); i++) { cout << vec[i] << ' '; } loops from 0 to size()-1, correctly accessing all elements forward.

3. Final Answer:

   for (int i = 0; i < vec.size(); i++) { cout << vec[i] << ' '; } -> Option A

4. Quick Check:

   Forward vector traversal uses i from 0 to size()-1 [OK]

Hint: Start from 0, go to less than size() for forward loops [OK]

Common Mistakes:

• Using i <= vec.size() causing out-of-range error
• Starting loop from 1 instead of 0
• Looping backwards for forward traversal

3. What is the output of the following C++ code?

std::vector<int> v = {10, 20, 30};
for (int i = v.size() - 1; i >= 0; i--) {
    std::cout << v[i] << ' ';
}

medium

A. 10 20 30

B. 30 20 10

C. 30 20

D. Runtime error

Solution

1. Step 1: Analyze loop start and end

   Loop starts at v.size()-1 = 2 and decrements to 0 inclusive.

2. Step 2: Trace output values

   v[2] = 30, v[1] = 20, v[0] = 10 printed in that order with spaces.

3. Final Answer:

   30 20 10 -> Option B

4. Quick Check:

   Backward traversal prints 30 20 10 [OK]

Hint: Backward vector loop starts at size()-1 down to 0 [OK]

Common Mistakes:

• Confusing forward and backward order
• Off-by-one errors in loop condition
• Expecting runtime error due to unsigned index

4. Identify the error in this backward traversal of a vector in C++:

std::vector<int> v = {1, 2, 3};
for (int i = v.size(); i >= 0; i--) {
    std::cout << v[i] << ' ';
}

medium

A. Vector cannot be traversed backward

B. Loop condition should be i > 0, not i >= 0

C. Loop starts at v.size(), which is out of range

D. No error, code runs fine

Solution

1. Step 1: Check loop start index

   v.size() is 3, but valid indices are 0 to 2, so v[3] is invalid.

2. Step 2: Understand consequences

   Accessing v[3] causes out-of-range error or undefined behavior.

3. Final Answer:

   Loop starts at v.size(), which is out of range -> Option C

4. Quick Check:

   Index must be less than size() [OK]

Hint: Start backward loop at size()-1, not size() [OK]

Common Mistakes:

• Starting loop at size() instead of size()-1
• Ignoring vector index bounds
• Assuming no error on out-of-range access

5. Given a doubly linked list with nodes 1 <-> 2 <-> 3, which code snippet correctly prints the list backward starting from tail in C++?

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

Node* tail = /* points to node with data 3 */;
// Which loop prints backward traversal?

hard

A. for (Node* cur = tail; cur->next != nullptr; cur = cur->next) { std::cout << cur->data << ' '; }

B. for (Node* cur = tail; cur != nullptr; cur = cur->next) { std::cout << cur->data << ' '; }

C. for (Node* cur = tail; cur->prev != nullptr; cur = cur->prev) { std::cout << cur->data << ' '; }

D. for (Node* cur = tail; cur != nullptr; cur = cur->prev) { std::cout << cur->data << ' '; }

Solution

1. Step 1: Understand doubly linked list backward traversal

   Backward traversal moves from tail to head using prev pointers.

2. Step 2: Check loop correctness

   for (Node* cur = tail; cur != nullptr; cur = cur->prev) { std::cout << cur->data << ' '; } starts at tail and moves using cur = cur->prev until nullptr, printing all nodes backward.

3. Final Answer:

   for (Node* cur = tail; cur != nullptr; cur = cur->prev) { std::cout << cur->data << ' '; } -> Option D

4. Quick Check:

   Backward traversal uses prev pointer from tail [OK]

Hint: Backward traversal uses prev pointer from tail to head [OK]

Common Mistakes:

• Using next pointer for backward traversal
• Stopping loop before head (checking cur->prev != nullptr)
• Starting from head instead of tail