Traversal Forward and Backward in DSA Java - Time & Space Complexity

Time Complexity: Traversal Forward and Backward

O(n)

Understanding Time Complexity

We want to understand how long it takes to move through a list from start to end and then back from end to start.

How does the time needed change as the list gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

// Assume a doubly linked list with head and tail nodes
Node current = head;
// Traverse forward
while (current != null) {
    System.out.print(current.data + " -> ");
    current = current.next;
}
System.out.print("null\n");

// Traverse backward
current = tail;
while (current != null) {
    System.out.print(current.data + " -> ");
    current = current.prev;
}
System.out.print("null\n");
    

This code moves through a doubly linked list first from the start to the end, then from the end back to the start, printing each element.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Two separate loops that visit each node once.
• How many times: Each loop runs once for every node in the list.

How Execution Grows With Input

As the list grows, the time to go forward and backward grows in a simple way.

Input Size (n)	Approx. Operations
10	About 20 steps (10 forward + 10 backward)
100	About 200 steps (100 forward + 100 backward)
1000	About 2000 steps (1000 forward + 1000 backward)

Pattern observation: The total steps double as the list size doubles, growing directly with the size.

Final Time Complexity

Time Complexity: O(n)

This means the time to traverse forward and backward grows in a straight line with the number of nodes.

Common Mistake

[X] Wrong: "Since we traverse twice, the time complexity is O(n²)."

[OK] Correct: Each traversal is separate and runs once over all nodes, so total steps add up, not multiply.

Interview Connect

Understanding how simple traversals scale helps you explain and optimize list operations clearly in interviews.

Self-Check

"What if we only traversed forward once but printed each node twice? How would the time complexity change?"

Practice

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

easy

A. Skipping every other node while visiting

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

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

D. Visiting nodes randomly without order

Solution

1. Step 1: Understand linked list structure

   A linked list has nodes connected from head to tail in one direction.

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 C

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 is random
• Assuming skipping nodes is traversal

2. Which Java code snippet correctly traverses a singly linked list forward?

easy

A. for(Node curr = tail; curr != null; curr = curr.prev) { System.out.print(curr.data + " "); }

B. for(Node curr = head; curr != null; curr = curr.next) { System.out.print(curr.data + " "); }

C. while(head != null) { System.out.print(head.data + " "); head = head.prev; }

D. for(Node curr = head; curr != null; curr = curr.prev) { System.out.print(curr.data + " "); }

Solution

1. Step 1: Identify forward traversal in singly linked list

   Forward traversal uses the next pointer starting from head.

2. Step 2: Check code correctness

   for(Node curr = head; curr != null; curr = curr.next) { System.out.print(curr.data + " "); } uses curr = head; curr != null; curr = curr.next which is correct for forward traversal.

3. Final Answer:

   for(Node curr = head; curr != null; curr = curr.next) { System.out.print(curr.data + " "); } -> Option B

4. Quick Check:

   Use next pointer from head for forward traversal [OK]

Hint: Use curr = curr.next starting at head for forward traversal [OK]

Common Mistakes:

• Using prev pointer in singly linked list
• Starting from tail in singly linked list
• Using wrong loop conditions

3. What is the output of this Java code for a doubly linked list with nodes 1 <-> 2 <-> 3 when traversed backward from tail?

Node tail = thirdNode; // node with data 3
Node curr = tail;
while(curr != null) {
    System.out.print(curr.data + " ");
    curr = curr.prev;
}

medium

A. 3 2 1

B. 1 2 3

C. 3 1 2

D. 2 3 1

Solution

1. Step 1: Understand doubly linked list backward traversal

   Backward traversal starts at tail and moves using prev pointer to head.

2. Step 2: Trace the loop output

   Starting at node 3, print 3, move to 2, print 2, move to 1, print 1, then stop.

3. Final Answer:

   3 2 1 -> Option A

4. Quick Check:

   Backward traversal prints 3 2 1 [OK]

Hint: Backward traversal prints from tail to head using prev [OK]

Common Mistakes:

• Confusing forward and backward traversal
• Printing nodes in wrong order
• Using next pointer instead of prev

4. Identify the error in this code snippet that tries to traverse a doubly linked list backward:

Node curr = head;
while(curr != null) {
    System.out.print(curr.data + " ");
    curr = curr.prev;
}

medium

A. Loop condition should be curr.next != null

B. Using next pointer instead of prev pointer

C. Missing initialization of curr

D. Starting traversal from head but using prev pointer causes null pointer error

Solution

1. Step 1: Analyze traversal start and direction

   Traversal starts at head but moves using prev pointer which is null at head.

2. Step 2: Identify error cause

   Using prev from head causes immediate null pointer or no traversal backward possible.

3. Final Answer:

   Starting traversal from head but using prev pointer causes null pointer error -> Option D

4. Quick Check:

   Backward traversal must start at tail, not head [OK]

Hint: Backward traversal must start at tail node [OK]

Common Mistakes:

• Starting backward traversal at head
• Confusing prev and next pointers
• Incorrect loop conditions

5. Given a doubly linked list, how can you print its elements forward and then backward without using extra space? Choose the best approach.

hard

A. Traverse forward from head to tail printing nodes, then traverse backward from tail to head printing nodes

B. Traverse forward twice from head to tail printing nodes both times

C. Traverse backward twice from tail to head printing nodes both times

D. Store all nodes in an array then print forward and backward from array

Solution

1. Step 1: Understand traversal without extra space

   Using the doubly linked list pointers allows forward and backward traversal without extra storage.

2. Step 2: Apply forward then backward traversal

   First traverse from head to tail printing nodes, then from tail to head printing nodes using prev pointers.

3. Final Answer:

   Traverse forward from head to tail printing nodes, then traverse backward from tail to head printing nodes -> Option A

4. Quick Check:

   Use head and tail pointers for forward and backward traversal [OK]

Hint: Use head for forward and tail for backward traversal [OK]

Common Mistakes:

• Using extra space unnecessarily
• Traversing only forward twice
• Confusing traversal directions