Pointer receivers in Go - Time & Space Complexity

Time Complexity: Pointer receivers

O(n)

Understanding Time Complexity

When using pointer receivers in Go methods, it's important to understand how this choice affects the speed of your program.

We want to see how the program's work changes as the input size grows when pointer receivers are involved.

Scenario Under Consideration

Analyze the time complexity of the following Go code using pointer receivers.

    type Counter struct {
        value int
    }

    func (c *Counter) Increment(n int) {
        for i := 0; i < n; i++ {
            c.value++
        }
    }
    

This code defines a Counter with a pointer receiver method that increments its value n times.

Identify Repeating Operations

Look at what repeats in the code.

• Primary operation: The for loop that increments the counter value.
• How many times: Exactly n times, where n is the input to Increment.

How Execution Grows With Input

As n grows, the number of increments grows the same way.

Input Size (n)	Approx. Operations
10	10 increments
100	100 increments
1000	1000 increments

Pattern observation: The work grows directly with n, so doubling n doubles the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run the Increment method grows linearly with the input size n.

Common Mistake

[X] Wrong: "Using a pointer receiver makes the method run faster regardless of input size."

[OK] Correct: Pointer receivers avoid copying the whole struct, but the loop inside still runs n times, so the time depends on n, not just the receiver type.

Interview Connect

Understanding how pointer receivers affect method performance helps you write clear and efficient Go code, a skill that shows you know how to manage resources well.

Self-Check

"What if the Increment method used a value receiver instead of a pointer receiver? How would the time complexity change?"