Course contentsShow
← JavaScript
Lesson 1904 of 2,72340. PerformanceFree lesson

Algorithmic Wins: Real-World Examples

See concrete examples where changing an algorithm (sorting, filtering, grouping) dramatically improved performance.

Algorithmic Wins: Real-World Examples

You'll learn: How choosing the right algorithm can transform slow, unusable code into fast, production-ready solutions through real-world scenarios.

Why Algorithms Matter in Practice

Understanding Big O notation is one thing—seeing it fix actual performance disasters is another. These examples show how swapping algorithms delivered dramatic improvements that users could feel.

Example 1: Sorting User Data

Before: A dashboard sorted 10,000 users by last activity using bubble sort (O(n²)). With nested loops, this took ~500ms on every filter change.

After: Switching to the built-in Array.sort() (typically QuickSort, O(n log n)) dropped the time to ~5ms—a 100x improvement. The UI became instantly responsive.

Example 2: Finding Duplicates

Before: Checking for duplicate emails in a registration list using nested loops:

// O(n²) - checks every pair
function hasDuplicates(emails) {
  for (let i = 0; i < emails.length; i++) {
    for (let j = i + 1; j < emails.length; j++) {
      if (emails[i] === emails[j]) return true;
    }
  }
  return false;
}

After: Using a Set for O(n) lookup:

// O(n) - single pass
function hasDuplicates(emails) {
  const seen = new Set();
  for (const email of emails) {
    if (seen.has(email)) return true;
    seen.add(email);
  }
  return false;
}

With 50,000 emails, this went from 45 seconds to 8 milliseconds.

Example 3: Grouping Items

Before: Filtering an array repeatedly to group items by category (O(n²)).

After: One pass with an object/Map to accumulate groups (O(n)). A product catalog with 100,000 items went from freezing the browser to rendering in under 100ms.

Key Takeaway: The biggest performance wins come from algorithmic improvements—not micro-optimizations. Changing from O(n²) to O(n) or O(n log n) can turn unusable code into production-ready solutions.