Implementing interfaces in Go - Time & Space Complexity

Time Complexity: Implementing interfaces

O(n)

Understanding Time Complexity

When we implement interfaces in Go, we want to know how the program's running time changes as we use these interfaces more.

We ask: How does the time to call interface methods grow when we have more data or calls?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

package main

import "fmt"

type Speaker interface {
    Speak()
}

type Person struct {
    name string
}

func (p Person) Speak() {
    fmt.Println("Hello, my name is", p.name)
}

func greetAll(speakers []Speaker) {
    for _, speaker := range speakers {
        speaker.Speak()
    }
}

func main() {
    people := []Person{{"Alice"}, {"Bob"}, {"Carol"}}
    var speakers []Speaker
    for _, p := range people {
        speakers = append(speakers, p)
    }
    greetAll(speakers)
}
    

This code defines an interface and calls its method on a list of objects implementing it.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping over the slice of speakers and calling the Speak() method on each.
• How many times: Once for each element in the speakers slice, so as many times as the number of speakers.

How Execution Grows With Input

As the number of speakers grows, the number of method calls grows the same way.

Input Size (n)	Approx. Operations
10	10 calls to Speak()
100	100 calls to Speak()
1000	1000 calls to Speak()

Pattern observation: The work grows directly with the number of speakers; double the speakers, double the calls.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line with the number of interface objects we call.

Common Mistake

[X] Wrong: "Calling methods through interfaces is slower and adds extra hidden loops that increase time complexity."

[OK] Correct: Calling an interface method adds a small fixed cost per call but does not add loops or change how many times the method runs. The main time depends on how many calls we make, not on the interface itself.

Interview Connect

Understanding how interface method calls scale helps you write clear and efficient Go code. It shows you can reason about performance while using Go's powerful features.

Self-Check

"What if we changed the slice of interface objects to a slice of concrete types and called methods directly? How would the time complexity change?"