Operator overloading concept in Kotlin - Time & Space Complexity

Time Complexity: Operator overloading concept

O(n)

Understanding Time Complexity

We want to understand how the time it takes to run code changes when we use operator overloading in Kotlin.

Specifically, we ask: how does the number of steps grow when we use overloaded operators on objects?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Vector(val x: Int, val y: Int) {
    operator fun plus(other: Vector): Vector {
        return Vector(x + other.x, y + other.y)
    }
}

fun sumVectors(vectors: List): Vector {
    var result = Vector(0, 0)
    for (v in vectors) {
        result = result + v
    }
    return result
}
    

This code defines a Vector class with an overloaded plus operator to add two vectors, then sums a list of vectors using this operator.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The loop that adds each vector to the result using the overloaded plus operator.
• How many times: Once for each vector in the list.

How Execution Grows With Input

Each vector in the list is added one by one, so the work grows as the list gets bigger.

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

Pattern observation: The number of operations grows directly with the number of vectors.

Final Time Complexity

Time Complexity: O(n)

This means the time to sum vectors grows in a straight line as the list gets longer.

Common Mistake

[X] Wrong: "Operator overloading makes the code slower in a way that changes the overall time complexity."

[OK] Correct: Operator overloading just replaces a function call with a nicer symbol. The number of operations stays the same, so the time complexity does not change.

Interview Connect

Understanding how operator overloading affects performance helps you explain your code clearly and shows you know how language features impact efficiency.

Self-Check

"What if the plus operator was overloaded to do more complex calculations inside? How would the time complexity change?"