Optimización de algoritmos

Optimización de algoritmos y complejidad

Mejorar el algoritmo suele aportar más rendimiento que micro‑optimizaciones. Conoce Big‑O y elige estructuras adecuadas.

Complejidad temporal

• O(1): Constante
• O(log n): Logarítmica
• O(n): Lineal
• O(n log n): Quicksort / mergesort
• O(n²): Bucles anidados

Ejemplos

// ❌ O(n²) - nested loop
function findDuplicates(arr) {
  const duplicates = [];
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[i] === arr[j]) duplicates.push(arr[i]);
    }
  }
  return duplicates;
}

// ✅ O(n) using Set
function findDuplicatesOptimized(arr) {
  const seen = new Set();
  const duplicates = new Set();
  
  for (const item of arr) {
    if (seen.has(item)) duplicates.add(item);
    else seen.add(item);
  }
  
  return [...duplicates];
}

Estructuras de datos

// Use Map for O(1) lookups
const map = new Map();
map.set('key', 'value');
map.get('key'); // O(1)

// Use Set for unique values
const unique = new Set([1, 2, 2, 3]);

// Use Object for simple hash
const cache = Object.create(null);
cache['key'] = 'value';

Optimizar búsquedas

// ❌ Linear search in array
const users = [{ id: 1 }, { id: 2 }];
const user = users.find(u => u.id === 2);

// ✅ Index by id
const userMap = new Map(users.map(u => [u.id, u]));
const userFast = userMap.get(2);