Comparison operators in Javascript - Time & Space Complexity

Time Complexity: Comparison operators

O(n)

Understanding Time Complexity

When using comparison operators in JavaScript, it's important to know how the time to compare values grows as the size of the data changes.

We want to understand how fast or slow these comparisons happen as inputs get bigger.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

const arr = [1, 2, 3, 4, 5];
const target = 3;

for (let i = 0; i < arr.length; i++) {
  if (arr[i] === target) {
    console.log('Found it!');
    break;
  }
}
    

This code checks each item in an array to find a target number using a comparison operator.

Identify Repeating Operations

• Primary operation: Comparing each array element to the target using ===.
• How many times: Up to once per element, until the target is found or the array ends.

How Execution Grows With Input

As the array gets bigger, the number of comparisons can grow up to the size of the array.

Input Size (n)	Approx. Operations
10	Up to 10 comparisons
100	Up to 100 comparisons
1000	Up to 1000 comparisons

Pattern observation: The number of comparisons grows roughly in a straight line with the size of the array.

Final Time Complexity

Time Complexity: O(n)

This means the time to find the target grows directly with the number of items you check.

Common Mistake

[X] Wrong: "Comparison operators take the same time no matter what data size or type they compare."

[OK] Correct: While simple comparisons are fast, comparing large or complex data (like big strings or objects) can take longer because each part must be checked.

Interview Connect

Understanding how comparison operations scale helps you explain how your code handles bigger data, showing you think about efficiency clearly.

Self-Check

"What if we changed the array to contain objects and compared them by reference instead of simple values? How would the time complexity change?"