Receiver types in Go - Time & Space Complexity

Time Complexity: Receiver types

O(n)

Understanding Time Complexity

When we use receiver types in Go methods, it affects how the program runs. We want to see how the choice between pointer and value receivers changes the work done by the program.

How does the program's work grow when using different receiver types?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

type Counter struct {
    count int
}

func (c Counter) IncrementValue() {
    c.count++
}

func (c *Counter) IncrementPointer() {
    c.count++
}

This code defines two methods for a Counter type: one uses a value receiver (increments a copy), the other a pointer receiver (increments the original).

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Incrementing the count field inside the method.
• How many times: Each method call performs this operation once.

There are no loops or recursion here; the main difference is how the receiver is passed (by value or pointer).

How Execution Grows With Input

Imagine calling these methods many times on a large number of Counter objects.

Input Size (n)	Approx. Operations
10	10 increments, each copying or referencing one Counter
100	100 increments, copying or referencing 100 Counters
1000	1000 increments, copying or referencing 1000 Counters

Using a value receiver means copying the whole Counter each time, so work grows linearly with n but with extra copying cost. Pointer receivers avoid copying, so work grows linearly but with less overhead.

Final Time Complexity

Time Complexity: O(n)

This means the time to run these methods grows directly with the number of calls, but pointer receivers do less work per call.

Common Mistake

[X] Wrong: "Using a value receiver is always faster because it avoids pointers."

[OK] Correct: Value receivers copy the entire object each call, which can be slower for large structs. Pointer receivers avoid copying and can be more efficient.

Interview Connect

Understanding how receiver types affect performance shows you think about how code runs, not just what it does. This skill helps you write clearer and faster Go programs.

Self-Check

"What if the Counter struct had many fields and was large? How would that change the time complexity impact of using value vs pointer receivers?"