Te sientas frente a la pantalla, el reclutador comparte un problema y el reloj empieza a correr. Si en ese momento no reconoces qué tipo de algoritmo aplica, el nerviosismo se dispara.
Sabemos que es la situación que más ansiedad genera entre programadores que buscan empleo, y tiene solución: dominar los algoritmos para entrevista técnica.
¿Pero cómo lo hacemos? Lo primero es organizarlos por categoría y, luego, sabiendo cuáles priorizar según el tiempo que tengas disponible.
En esta guía vas a encontrar cada categoría explicada con ejemplos, una tabla con los algoritmos que más se repiten en procesos reales y un arsenal de repositorios, herramientas visuales y sitios de práctica para llegar preparado.
Por qué dominar algoritmos es clave en una entrevista técnica de programación
Siempre nos preguntan por qué las empresas hacen pruebas básicas de algoritmos en una entrevista.
Nosotros solemos responder que no preguntamos algoritmos porque vayas a implementar quicksort desde cero en tu trabajo diario (mucho menos ahora que tenemos a Claude, Codex, etcétera). Lo hacemos porque resolver un problema algorítmico revela un poco sobre cómo piensas y sobre tus conocimientos básicos de algorítmica y programación.
Descompones el problema, evalúas alternativas y eliges la más eficiente. Ese proceso mental es justo lo que un equipo de ingeniería necesita ver antes de contratarte.
Además, hay una razón práctica: Las empresas grandes procesan datos a una escala donde la diferencia entre un algoritmo O(n) y uno O(n²) se traduce en servidores adicionales y en segundos de espera para millones de usuarios.
Saber elegir la estructura correcta importa, y no solo en la entrevista.
Entrevista técnica de programación: guía completa para prepararte y destacar
Tipos de entrevista, qué te van a preguntar y cómo prepararte paso a paso, más allá de los algoritmos.
Big O notation y complejidad temporal y espacial: la base antes de estudiar algoritmos
Antes de memorizar algoritmos, necesitas el lenguaje para compararlos. Ahí entra la notación Big O, que describe cómo crece el tiempo de ejecución o el uso de memoria de un algoritmo a medida que aumenta el tamaño de los datos de entrada.
No se trata de contar operaciones exactas, sino de entender la tendencia. Un algoritmo O(log n) escala mucho mejor que uno O(n²) cuando el volumen de datos crece.
Las complejidades que vas a encontrar constantemente en entrevistas son estas:
- O(1): tiempo constante, no depende del tamaño de los datos (acceder a un elemento de un array por índice).
- O(log n): crece muy lento, típico de la búsqueda binaria.
- O(n): crece de forma proporcional, como recorrer un array una vez.
- O(n log n): propio de los algoritmos de ordenamiento eficientes, como mergesort.
- O(n²): dos loops anidados, común en soluciones fuerza bruta que hay que optimizar.
La complejidad espacial sigue la misma lógica, pero mide memoria en lugar de tiempo. Un entrevistador experimentado quiere ver que analizas ambas antes de declarar tu solución como «terminada». Puedes profundizar en el tema con la explicación de Big O notation de GeeksforGeeks, una referencia estándar en la industria.
Algoritmos de ordenamiento y búsqueda
Esta categoría es la puerta de entrada a casi cualquier entrevista técnica de programación, porque aparece disfrazada dentro de problemas más complejos.
Bubble sort, selection sort e insertion sort son los algoritmos de ordenamiento más simples. Casi nunca se usan en producción por su complejidad O(n²), pero siguen apareciendo como pregunta de fundamentos para verificar que entiendes la lógica básica de comparar e intercambiar.
function bubbleSort(arr) {
let n = arr.length;
let swapped;
do {
swapped = false;
for (let i = 0; i < n - 1; i++) {
if (arr[i] > arr[i + 1]) {
// Intercambiar elementos usando destructuración de JS
[arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];
swapped = true;
}
}
// Reducimos n porque el último elemento ya quedó en su posición correcta
n--;
} while (swapped);
return arr;
}
// Ejemplo de uso:
const numerosBubble = [64, 34, 25, 12, 22, 11, 90];
console.log("Bubble Sort:", bubbleSort(numerosBubble));
// Resultado: [11, 12, 22, 25, 34, 64, 90]Quicksort y mergesort son los que realmente importan en la práctica. Quicksort elige un pivote y particiona el array alrededor de él, con un rendimiento promedio de O(n log n). Mergesort divide el array a la mitad de forma recursiva y luego combina las partes ordenadas, garantizando O(n log n) incluso en el peor caso.
function quickSortFunctional(arr) {
// Caso base: arreglos de longitud 0 o 1 ya están ordenados
if (arr.length <= 1) {
return arr;
}
// Tomamos el último elemento como pivote
const pivot = arr[arr.length - 1];
const left = [];
const right = [];
// Dividir los elementos comparando contra el pivote
for (let i = 0; i < arr.length - 1; i++) {
if (arr[i] < pivot) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
// Combinar: izquierda ordenada + pivote + derecha ordenada
return [...quickSortFunctional(left), pivot, ...quickSortFunctional(right)];
}
// Ejemplo de uso:
const numerosFunctional = [10, 80, 30, 90, 40, 50, 70];
console.log("Quicksort Funcional:", quickSortFunctional(numerosFunctional));
// Resultado: [10, 30, 40, 50, 70, 80, 90]En búsqueda, la estrella indiscutida es la búsqueda binaria. Funciona solo sobre datos ordenados, divide el espacio de búsqueda a la mitad en cada paso y logra una complejidad de O(log n). Es, probablemente, el algoritmo que más veces vas a necesitar adaptar durante una entrevista, porque aparece en variantes como «encuentra el primer elemento mayor que X» o «busca en un array rotado».
function binarySearch(arr, target) {
let left = 0;
let right = arr.length - 1;
while (left <= right) {
// Calcular el índice medio para evitar desbordamiento numérico
const mid = Math.floor(left + (right - left) / 2);
// ¿Encontramos el elemento?
if (arr[mid] === target) {
return mid; // Retorna el índice donde se encuentra
}
// Si el objetivo es menor, buscamos en la mitad izquierda
if (target < arr[mid]) {
right = mid - 1;
}
// Si el objetivo es mayor, buscamos en la mitad derecha
else {
left = mid + 1;
}
}
return -1; // Elemento no encontrado
}
// Ejemplo de uso (Arreglo obligatoriamente ordenado):
const numeros = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91];
console.log("Índice de 23:", binarySearch(numeros, 23));
// Resultado: 5
console.log("Índice de 100:", binarySearch(numeros, 100));
// Resultado: -1 (no existe)Algoritmos de recorrido: BFS, DFS y árboles binarios
Cuando el problema involucra árboles o grafos, casi siempre la solución empieza con uno de estos dos recorridos.
DFS (Depth-First Search) explora una rama hasta el final antes de retroceder. Se implementa con recursión o con una pila, y es la base de los recorridos preorder, inorder y postorder en árboles binarios. También sirve para detectar ciclos y resolver problemas de backtracking.
BFS (Breadth-First Search) explora nivel por nivel, usando una cola. Es la elección natural cuando necesitas el camino más corto en un grafo no ponderado, o cuando el problema pide procesar los nodos «por capas».
La diferencia práctica entre ambos suele decidir si tu solución es correcta o no: si el problema pide la ruta más corta, BFS gana casi siempre. Si necesitas explorar todas las combinaciones posibles, DFS con backtracking es tu herramienta.
Estructuras de datos clave: hash maps, pilas y colas
Aunque este es un artículo sobre algoritmos para entrevistas técnicas de programación. Ningún algoritmo funciona en el vacío, necesita una estructura de datos que lo soporte, y estas tres son las que más se repiten en entrevistas.
- Los hash maps (o tablas hash) permiten búsqueda, inserción y eliminación en tiempo O(1) promedio. Convierten problemas que parecerían requerir O(n²) en soluciones O(n), simplemente guardando lo que ya viste mientras recorres los datos una sola vez.
- Las pilas (stacks) siguen el principio LIFO (el último en entrar es el primero en salir). Son la base de DFS, de la validación de paréntesis balanceados y del historial de «deshacer» en cualquier aplicación.
- Las colas (queues) siguen el principio FIFO (el primero en entrar es el primero en salir), y son indispensables para implementar BFS y para simular procesos que se atienden en orden de llegada.
Técnicas y patrones de resolución de problemas algorítmicos
Aquí es donde muchos candidatos se estancan: conocen los algoritmos por separado, pero no reconocen qué patrón aplica frente a un problema nuevo. Dominar estos patrones acelera muchísimo la resolución.
Two pointers (dos punteros)
Consiste en usar dos índices que recorren una estructura, generalmente un array ordenado, desde extremos opuestos o a distinta velocidad. Reduce soluciones que parecían necesitar O(n²) a O(n), y es habitual en problemas de suma de pares o de eliminación de duplicados.
Sliding window (ventana deslizante)
Mantiene un subconjunto contiguo de elementos (la «ventana») que se expande o contrae según una condición. Es el patrón indicado cuando el problema menciona «subarray» o «substring» contiguo con alguna restricción, como la suma máxima de tamaño fijo.
Programación dinámica
La programación dinámica resuelve problemas dividiéndolos en subproblemas más pequeños y guardando sus resultados para no recalcularlos. Aplica cuando el problema tiene subestructura óptima y subproblemas superpuestos, como en el cálculo de la secuencia de Fibonacci de forma eficiente o en el problema de la mochila.
Se implementa de dos formas: memoización (de arriba hacia abajo, usando recursión con caché) o tabulación (de abajo hacia arriba, llenando una tabla de forma iterativa). Es, sin exagerar, el tema que más entrevistas de nivel medio y senior hace fallar a los candidatos, así que merece práctica dedicada.
Recursión y backtracking
La recursión resuelve un problema llamándose a sí misma con una versión más pequeña del mismo problema. El backtracking añade una capa: prueba una solución parcial, y si no funciona, retrocede y prueba otra. Es el patrón detrás de problemas como generar permutaciones, resolver sudokus o el clásico problema de las N reinas.
Algoritmos greedy (voraces)
Un algoritmo greedy toma, en cada paso, la decisión que parece mejor en ese momento, sin reconsiderar decisiones anteriores. Funciona muy bien en problemas como Dijkstra para caminos más cortos o en la codificación de Huffman, pero no siempre garantiza la solución óptima global. Reconocer cuándo un enfoque greedy es válido (y cuándo necesitas programación dinámica en su lugar) es una habilidad que los entrevistadores valoran mucho.
Portafolio de programador: cómo armarlo para impresionar a reclutadores
Qué incluir, qué plataformas usar gratis y qué errores evitar para que tu portafolio sí consiga entrevistas.
¿Cuáles son los 10 algoritmos más utilizados en entrevistas?
Con tiempo limitado, priorizar importa más que cubrir todo. Esta tabla resume los algoritmos y técnicas que, en la práctica, aparecen con más frecuencia en procesos de selección técnica.
| Algoritmo o técnica | Categoría | Complejidad temporal | Por qué aparece tanto en entrevistas |
|---|---|---|---|
| Búsqueda binaria | Búsqueda | O(log n) | Base de decenas de variantes sobre arrays ordenados |
| BFS (Breadth-First Search) | Grafos y árboles | O(V + E) | Camino más corto y recorridos por niveles |
| DFS (Depth-First Search) | Grafos y árboles | O(V + E) | Recorridos de árboles, backtracking y detección de ciclos |
| Quicksort | Ordenamiento | O(n log n) promedio | Ordenamiento eficiente in-place, muy preguntado en teoría |
| Mergesort | Ordenamiento | O(n log n) | Estable y predecible, clave en listas enlazadas |
| Two pointers | Técnica | O(n) | Convierte soluciones O(n²) en lineales |
| Sliding window | Técnica | O(n) | Estándar en problemas de subarrays y substrings |
| Programación dinámica | Técnica | Variable según el problema | El tema que más entrevistas de nivel medio y senior decide |
| Recursión y backtracking | Técnica | Variable según el problema | Combinatoria, permutaciones y problemas de restricciones |
| Algoritmos greedy | Técnica | Variable según el problema | Decisiones óptimas locales en problemas de optimización |
Cómo prepararte para una entrevista técnica de programación: tu arsenal de algoritmos
Entender la teoría es la mitad del camino. La otra mitad es práctica constante, y por suerte existen recursos gratuitos de altísima calidad para construir tu arsenal.
Repositorios de GitHub gratuitos para estudiar
El repositorio Guía para Entrevistas Laborales de Programación, creado por holasoymalva, reúne teoría, ejemplos de código y desafíos organizados por fundamentos y por stack tecnológico, todo en español y de acceso abierto.
También vale la pena revisar Coding Interview University, un plan de estudio completo pensado para programadores autodidactas, con más de 300.000 estrellas en GitHub y una hoja de ruta de varios meses.
Tech Interview Handbook combina algoritmos, diseño de sistemas y preparación para preguntas de comportamiento, con hojas de referencia rápida muy usadas por candidatos que aplican a big tech.
Si prefieres ver implementaciones reales en código, TheAlgorithms/Python ofrece cientos de algoritmos clásicos programados en Python, con ejemplos claros para cada categoría de esta guía.
Herramientas visuales para aprender algoritmos
Leer pseudocódigo no siempre alcanza para entender por qué un algoritmo funciona. Aquí es donde las herramientas visuales marcan la diferencia.
VisuAlgo fue desarrollada en la Universidad Nacional de Singapur y ofrece animaciones interactivas de más de veinte estructuras de datos y algoritmos, disponibles en español, con módulos de entrenamiento para practicar.
Python Tutor te permite ejecutar tu código paso a paso y ver cómo cambian las variables, la pila de llamadas y las estructuras de datos en cada línea, algo muy útil para depurar recursión y backtracking.
Algorithm Visualizer muestra la ejecución de algoritmos en tiempo real junto al código fuente en varios lenguajes, ideal para conectar la teoría con la implementación.
LeetCode y otros sitios para practicar
LeetCode sigue siendo el estándar de la industria, con miles de problemas categorizados por dificultad y empresa. Pero no es la única opción, y combinar plataformas suele acelerar el aprendizaje.
NeetCode organiza los problemas por patrón (no por dificultad aislada), con listas curadas como NeetCode 150 que muchos candidatos usan como ruta de estudio estructurada.
HackerRank ofrece desafíos por dominio, incluyendo algoritmos, estructuras de datos y bases de datos, y es además la plataforma que usan muchas empresas para el filtro técnico inicial.
Codewars gamifica la práctica con «katas» de dificultad progresiva en más de cincuenta lenguajes, una opción entretenida para mantener la constancia.
Exercism suma mentoría humana gratuita sobre tus soluciones, algo que la mayoría de plataformas automatizadas no ofrece.
En nuestra experiencia acompañando a desarrolladores en procesos de selección, la combinación que mejor funciona es esta: estudiar la teoría con un repositorio o una herramienta visual, practicar el patrón específico en NeetCode o LeetCode, y simular entrevistas reales antes de presentarte al proceso final.
Habilidades IT más demandadas por empresas en 2026 (incluye IA)
Qué buscan hoy las empresas más allá de los algoritmos: IA, ciberseguridad, cloud y los nuevos roles tech.
Preguntas frecuentes
¿Cuáles son los 10 algoritmos más utilizados?
Los que más se repiten en procesos de selección son búsqueda binaria, BFS, DFS, quicksort, mergesort, two pointers, sliding window, programación dinámica, recursión con backtracking y algoritmos greedy. La tabla de esta guía detalla por qué cada uno aparece tanto.
¿Cuáles son los 4 tipos de algoritmos?
Una clasificación clásica agrupa los algoritmos en cuatro grandes enfoques: divide y vencerás (dividir el problema en partes más pequeñas), programación dinámica (reutilizar soluciones a subproblemas), algoritmos greedy (decisiones óptimas locales) y backtracking (probar soluciones parciales y retroceder cuando fallan). Muchos algoritmos concretos, como quicksort o mergesort, son aplicaciones específicas de divide y vencerás.
¿Qué preguntas sobre algoritmos hacen en una entrevista técnica?
Suelen pedirte resolver un problema en vivo (por ejemplo, encontrar el subarray con la suma máxima, invertir un árbol binario o detectar un ciclo en una lista enlazada), explicar la complejidad temporal y espacial de tu solución, y a veces comparar dos enfoques distintos para el mismo problema, justificando cuál conviene según el contexto.
¿Qué es un algoritmo y 5 ejemplos?
Un algoritmo es una secuencia finita y ordenada de pasos que resuelve un problema o realiza una tarea específica. Cinco ejemplos comunes son la búsqueda binaria, el algoritmo de ordenamiento quicksort, el recorrido BFS en grafos, el algoritmo de Dijkstra para caminos más cortos y la programación dinámica aplicada al problema de la mochila.
Convierte esta preparación en resultados
Dominar los algoritmos para entrevista técnica por categorías, entender cuáles priorizar y practicar con las herramientas correctas es el camino más corto hacia esa oferta que buscas.
En Apok, C.A. llevamos más de 13 años formando y conectando talento técnico con empresas de desarrollo de software y staffing TI dentro y fuera de LATAM. Si estás en la búsqueda de empleo, puedes enviarnos tu CV y nos pondremos en contacto contigo en caso de tener una oportunidad para ti.
SEO estratega y redactor de contenidos especializado en temas de tecnología. Experto en crear estrategias de contenido que comunican complejidad técnica de forma clara y accesible.
