Flow builder and collect in Kotlin - Time & Space Complexity

Time Complexity: Flow builder and collect

O(n)

Understanding Time Complexity

We want to understand how the time needed to run a Kotlin flow changes as we add more items to it.

How does the flow builder and collecting values scale with input size?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

import kotlinx.coroutines.flow.*

fun simpleFlow(n: Int) = flow {
    for (i in 1..n) {
        emit(i)
    }
}

suspend fun collectFlow(n: Int) {
    simpleFlow(n).collect { value ->
        println(value)
    }
}

This code creates a flow that emits numbers from 1 to n, then collects and prints each number.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Loop inside the flow builder that emits n values.
• How many times: Exactly n times, once for each number from 1 to n.
• Collection operation: The collect block processes each emitted value once, also n times.

How Execution Grows With Input

As n grows, the number of emitted and collected items grows linearly.

Input Size (n)	Approx. Operations
10	About 10 emits and 10 collects
100	About 100 emits and 100 collects
1000	About 1000 emits and 1000 collects

Pattern observation: The work grows directly in proportion to n, doubling n doubles the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to emit and collect all values grows linearly with the number of items.

Common Mistake

[X] Wrong: "The flow emits all values instantly, so time does not depend on n."

[OK] Correct: Each value is emitted and collected one by one, so more items mean more work and more time.

Interview Connect

Understanding how flows work with many items helps you reason about performance in real apps that use streams of data.

Self-Check

What if we changed the flow to emit values in parallel using multiple flows merged together? How would the time complexity change?