Learn how while loops repeatedly execute DSA operations while a condition remains true, including traversal, pointer movement, termination, and complexity.

Gaurav 25 Sep 2026 6 min read Sign in to save

On this page

for loop
while loop
Linear
Logarithmic
Quadratic
Pattern 1: Pointer Traversal
Pattern 2: Two Pointers
Pattern 3: Search Until Found
Pattern 4: Shrink a Range
Pattern 5: Process Until State Changes
Forgetting to Update the Loop State
Wrong Boundary Condition
Updating the Wrong Pointer
Incorrect continue Usage

While Loop

A while loop repeatedly executes an operation as long as a condition remains true.

In DSA, while loops are useful when the number of iterations is not known in advance and depends on the state of the algorithm.

Common uses include:

Traversing data using a condition
Moving pointers
Processing elements until a condition changes
Repeating an operation until a result is found
Implementing two-pointer techniques
Sliding-window algorithms
Processing linked lists
Controlling iterative algorithms

The basic idea is:

while condition is true
    perform operation

1. Basic Structure

A while loop has two important parts:

while condition
    operation

The condition is checked before every iteration.

Example:

i = 0

while i < 5
    process i
    i++

The values processed are:

When:

i = 5

the condition:

i < 5

becomes false and the loop stops.

2. How a `while` Loop Works

Consider:

i = 0

while i < 3
    process i
    i++

Execution:

i = 0
   ↓
0 < 3 → true
   ↓
process 0
   ↓
i++
   ↓
i = 1
   ↓
1 < 3 → true
   ↓
process 1
   ↓
i++
   ↓
i = 2
   ↓
2 < 3 → true
   ↓
process 2
   ↓
i++
   ↓
i = 3
   ↓
3 < 3 → false
   ↓
Stop

The important point is that the loop continues based on a condition, not simply a fixed number of iterations.

3. `while` Loop for Array Traversal

A while loop can be used to traverse an array.

Given:

arr = [10, 20, 30, 40, 50]

We can write:

i = 0

while i < arr.length
    process arr[i]
    i++

The loop processes:

The condition:

i < arr.length

controls whether another element remains to be processed.

4. `while` Loop vs `for` Loop

Both can perform repeated operations, but they are useful in different situations.

`for` loop

Usually preferred when the iteration structure is clearly defined.

for i = 0 to n - 1
    process arr[i]

`while` loop

Useful when the continuation condition is more important than a fixed iteration count.

while condition
    perform operation

For example, an algorithm may continue until:

target is found

or:

window becomes valid

or:

left pointer crosses right pointer

The choice depends on the algorithm.

5. Pointer Movement

One of the most important DSA uses of while loops is pointer movement.

For example:

left = 0
right = n - 1

while left < right
    process arr[left] and arr[right]

    left++
    right--

The loop continues while:

left < right

This pattern is common in:

Two-pointer problems
Palindrome problems
Array problems
Searching problems

6. Two-Pointer Example

Consider:

arr = [1, 2, 3, 4, 5]

We start with:

left = 0
right = 4

Then:

while left < right

The pointers move toward each other:

left →        ← right

1  2  3  4  5
↑           ↑

   1  2  3  4  5
      ↑     ↑

   1  2  3  4  5
         ↑

The loop stops when:

left >= right

This is a common condition-based iteration pattern.

7. Palindrome Pattern

A palindrome reads the same from both directions.

For example:

"madam"

A two-pointer solution can use a while loop:

left = 0
right = length - 1

while left < right

    if string[left] != string[right]
        return false

    left++
    right--

return true

The loop continues while there are still two characters to compare.

The important condition is:

left < right

This pattern is commonly used for palindrome-related problems.

8. Searching with a `while` Loop

A search can also be implemented using a while loop.

i = 0

while i < n

    if arr[i] == target
        return i

    i++

return -1

The loop continues until:

The target is found, or
All elements have been checked.

For an array of size n, the worst-case time complexity is:

O(n)

9. Processing Until a Condition Changes

A while loop is useful when an algorithm needs to continue until some state changes.

For example:

while value > 0
    process value
    value = value / 2

The number of iterations depends on how quickly value changes.

If the value is repeatedly divided by 2, the number of iterations is approximately:

O(log n)

This type of pattern appears in algorithms where the problem size decreases during each iteration.

10. Sliding Window Pattern

while loops are frequently used in sliding-window algorithms.

A simplified pattern is:

right = 0
left = 0

while right < n

    add arr[right]

    while window is invalid
        remove arr[left]
        left++

    right++

The inner while loop shrinks the window until the required condition is satisfied.

The important idea is:

Expand window
      ↓
Check condition
      ↓
Invalid?
      ↓
Shrink window

This pattern is common in substring and subarray problems.

11. Linked List Traversal

A while loop is a natural choice for traversing a linked list.

current = head

while current != null
    process current
    current = current.next

The loop continues while a valid node exists.

The termination condition is:

current == null

Once the end of the linked list is reached, the loop stops.

For a linked list containing n nodes:

Time Complexity = O(n)

12. Nested `while` Loops

A while loop can contain another while loop.

Example:

while condition1

    while condition2
        process

The complexity depends on how many times each loop executes.

If both loops independently process n elements:

O(n²)

However, nested loops do not automatically mean O(n²). The actual number of iterations must be analyzed.

13. `break` in a `while` Loop

break immediately terminates the loop.

Example:

while i < n

    if arr[i] == target
        break

    i++

If the target is found, there is no need to continue.

This is useful when an algorithm has found the required result before reaching the normal loop boundary.

14. `continue` in a `while` Loop

continue skips the current iteration and moves to the next iteration.

Example:

while i < n

    if arr[i] < 0
        i++
        continue

    process arr[i]

    i++

When using continue, make sure the loop's control variable is updated appropriately.

Otherwise, the loop may never terminate.

15. Infinite Loops

A while loop can become infinite if its condition never becomes false.

For example:

i = 0

while i < n
    process i

If i is never changed, the condition remains true.

A correct version is:

i = 0

while i < n
    process i
    i++

Always identify what will eventually make the loop condition false.

16. Loop Termination

When designing a while loop, ask:

What is the starting state?
What condition keeps the loop running?
What changes during each iteration?
What condition causes the loop to stop?

For example:

left = 0
right = n - 1

while left < right

    process

    left++
    right--

Here:

Starting state: left = 0, right = n - 1
Continuation condition: left < right
State change: left++, right--
Termination: left >= right

Understanding these four parts helps prevent incorrect loops.

17. Time Complexity of `while` Loops

The complexity of a while loop depends on how many iterations it performs.

Linear

i = 0

while i < n
    i++

Iterations:

Time complexity:

O(n)

Logarithmic

i = n

while i > 1
    i = i / 2

The value is repeatedly divided by 2.

Time complexity:

O(log n)

Quadratic

If a loop contains another loop and both perform approximately n iterations:

while condition
    while another condition
        process

The complexity can be:

O(n²)

Always analyze the number of iterations rather than judging complexity from syntax alone.

18. Common DSA Patterns

Pattern 1: Pointer Traversal

i = 0

while i < n
    process arr[i]
    i++

Pattern 2: Two Pointers

left = 0
right = n - 1

while left < right
    process
    move pointers

Pattern 3: Search Until Found

while elements remain
    if target found
        return result

Pattern 4: Shrink a Range

while condition
    reduce search space

Pattern 5: Process Until State Changes

while state is valid
    update state

Recognizing these patterns is useful when converting a problem statement into an algorithm.

19. Common Mistakes

Forgetting to Update the Loop State

Incorrect:

i = 0

while i < n
    process arr[i]

Correct:

i = 0

while i < n
    process arr[i]
    i++

Wrong Boundary Condition

For two pointers, these conditions are different:

left < right

and:

left <= right

The correct one depends on whether the middle element needs to be processed.

Updating the Wrong Pointer

In a two-pointer algorithm, moving the wrong pointer can cause:

Incorrect results
Missed elements
Infinite loops

Always determine why each pointer moves.

Incorrect `continue` Usage

If a control variable is not updated before continue, the loop may repeatedly process the same state.

20. `while` Loop and Algorithmic Thinking

When using a while loop in DSA, do not think only about syntax.

Think about the state of the algorithm.

Ask:

What state am I tracking?
        ↓
What condition keeps the algorithm running?
        ↓
How does the state change?
        ↓
When does the algorithm terminate?

For example, in a two-pointer problem:

State:
left, right

Condition:
left < right

Update:
left++, right--

Termination:
left >= right

This way of thinking is more useful than simply memorizing loop syntax.

Quick Reference

Use Case	Typical Pattern
Array traversal	`while i < n`
Linked list	`while current != null`
Two pointers	`while left < right`
Search	`while elements remain`
Sliding window	`while window is invalid`
Shrinking problem	`while size > 1`
Early termination	`break`
Skip iteration	`continue`

Key Takeaways

A while loop repeats an operation while a condition remains true.
It is useful when the number of iterations depends on the algorithm's state.
while loops are common in pointer-based DSA techniques.
Two-pointer algorithms frequently use while.
Linked-list traversal commonly uses while.
Sliding-window algorithms often use while to expand or shrink a window.
The loop must change its state so that the termination condition can eventually become true.
Incorrect boundaries can cause missed elements or incorrect results.
An infinite loop occurs when the termination condition is never reached.
Time complexity depends on the number of iterations.
Always identify the loop's state, condition, update, and termination point.

Practice Questions

Traverse an array using a while loop.
Search for an element using a while loop.
Find the maximum element using a while loop.
Reverse an array using two pointers.
Check whether a string is a palindrome.
Count the occurrences of a target value.
Find the first occurrence of an element.
Implement a two-pointer pair-sum solution.
Determine the time complexity of a given while loop.
Identify and fix an infinite loop.

What's Next?

A while loop provides condition-based iteration. Another useful loop structure is the do-while loop, where the algorithm executes the operation once before checking the condition.

Found a problem on this page, or something that could be clearer?

What kind of thing?

What happened?

Email — only if you want a reply

Goes straight to the author. Not published anywhere.

While Loop

While Loop

1. Basic Structure

2. How a while Loop Works

3. while Loop for Array Traversal

4. while Loop vs for Loop

for loop

while loop

5. Pointer Movement

6. Two-Pointer Example

7. Palindrome Pattern

8. Searching with a while Loop

9. Processing Until a Condition Changes

10. Sliding Window Pattern

11. Linked List Traversal

12. Nested while Loops

13. break in a while Loop

14. continue in a while Loop

15. Infinite Loops

16. Loop Termination

17. Time Complexity of while Loops

Linear

Logarithmic

Quadratic

18. Common DSA Patterns

Pattern 1: Pointer Traversal

Pattern 2: Two Pointers

Pattern 3: Search Until Found

Pattern 4: Shrink a Range

Pattern 5: Process Until State Changes

19. Common Mistakes

Forgetting to Update the Loop State

Wrong Boundary Condition

Updating the Wrong Pointer

Incorrect continue Usage

20. while Loop and Algorithmic Thinking

Quick Reference

Key Takeaways

Practice Questions

What's Next?

2. How a `while` Loop Works

3. `while` Loop for Array Traversal

4. `while` Loop vs `for` Loop

`for` loop

`while` loop

8. Searching with a `while` Loop

12. Nested `while` Loops

13. `break` in a `while` Loop

14. `continue` in a `while` Loop

17. Time Complexity of `while` Loops

Incorrect `continue` Usage

20. `while` Loop and Algorithmic Thinking