Estructura de Datos y Algoritmos · DacaCode

Tablas Hash, Pilas y Colas: Estructuras de Datos de Alto Rendimiento

Dacadev — Tue, 19 May 2026 00:00:00 -0500

Tabla de Contenido

Hasta ahora hemos visto estructuras secuenciales como los Arrays, donde buscar un elemento requiere revisar celda por celda O(N) o usar búsqueda binaria O(log N) si están ordenados. Pero, ¿qué pasaría si te dijera que existe una estructura capaz de buscar, insertar y borrar datos en un solo paso O(1)?

Hoy explicaremos las Tablas Hash (Hash Tables),las Pilas (Stacks) y las Colas (Queues).

1. ¿Qué es una Tabla Hash (Hash Table)?

Una Tabla Hash (conocida en Python como diccionario, en JavaScript como objeto o Map, y en Go como map) es una estructura que asocia claves (keys) con valores (values).

A diferencia de los Arrays, donde los elementos están ordenados por índices numéricos continuos, las Tablas Hash son estructuras no ordenadas. Su velocidad absurda radica en su proceso interno: el Hashing.

¿Cómo funciona el Hashing?

Cuando guardamos un dato en una Tabla Hash (por ejemplo, {"cab" => "taxi"}), la computadora no busca una celda libre al azar. Utiliza una función hash (hash function) para convertir la clave de texto en un índice numérico específico.

Supongamos que inventamos una función hash súper simple que suma el valor alfabético de las letras de la clave:

A = 1, B = 2, C = 3, D = 4, E = 5

Si guardamos la clave "ACE":

A(1) + C(3) + E(5) = 9. El valor se almacena en el índice 9 de nuestra memoria física.

Si guardamos "CAB":

C(3) + A(1) + B(2) = 6. El valor se almacena en el índice 6.

flowchart LR
 Key["Clave: 'ACE'"] --> HashFunc["Función Hash
(Suma de letras)"]
 HashFunc --> Index["Índice: 9"]
 Index --> Memory["[Celda 9] = 'star'"]

Cuando quieres buscar el valor asociado a "ACE", la computadora no recorre toda la tabla. Simplemente calcula de nuevo Hash("ACE") = 9 y accede de forma instantánea al índice 9 en 1 paso (O(1)). ¡Es brillante!

Colisiones y Load Factor

¿Qué pasa si intentamos insertar "DAB" en nuestro ejemplo anterior?

D(4) + A(1) + B(2) = 7 ¿Y si intentamos insertar "BAD"?
B(2) + A(1) + D(4) = 7

Ambas claves dan el mismo índice, a esto se le conoce como Colisión Hash. Cuando esto ocurre, la celda 7 debe almacenar una sub-lista de valores, lo que degrada el rendimiento de la búsqueda.

Para evitar colisiones en la vida real, las funciones hash usan matemáticas complejas y se rigen por la regla del Factor de Carga (Load Factor):

La proporción ideal es tener 10 celdas de memoria por cada 7 elementos almacenados (un factor de carga de 0.7). Esto mantiene un equilibrio perfecto entre uso de memoria y prevención de colisiones.

Eficiencia de las Operaciones en una Hash Table

Operación	Por Clave (Key)	Por Valor (Value)
Búsqueda	O(1) (Constante)	O(N) (Lineal)
Inserción	O(1) (Constante)	-
Eliminación	O(1) (Constante)	-

Note

La búsqueda de O(1) solo funciona en una dirección: desde la clave al valor. Si necesitas buscar una clave a partir de su valor, la computadora obligatoriamente deberá recorrer toda la estructura de forma lineal (O(N)).

Ejemplo Práctico: Optimizando código con Tablas Hash

Imagina que debes escribir una función en TypeScript que determine si un arreglo es un subconjunto de otro (es decir, si todos los elementos de un arreglo array2 existen en array1).

La versión lenta (O(N \cdot M)) - Bucles anidados:

function isSubsetSlow<T>(arr1: T[], arr2: T[]): boolean {
 // Compara cada elemento del segundo arreglo contra todos los del primero
 for (const val2 of arr2) {
 let found: boolean = false;
 for (const val1 of arr1) {
 if (val2 === val1) {
 found = true;
 break;
 }
 }
 if (!found) return false;
 }
 return true;
}

La versión veloz (O(N + M)) - Usando una Tabla Hash:

function isSubsetFast<T extends PropertyKey>(arr1: T[], arr2: T[]): boolean {
 const hashTable: Record<T, boolean> = {} as Record<T, boolean>;

 // Guardamos todos los elementos de arr1 en la tabla hash en O(N)
 for (const value of arr1) {
 hashTable[value] = true;
 }

 // Comprobamos la existencia de arr2 en O(M)
 for (const value of arr2) {
 if (!hashTable[value]) {
 return false;
 }
 }
 return true;
}

Al transformar la búsqueda lineal anidada en una búsqueda instantánea en una Tabla Hash, convertimos un algoritmo pesado de complejidad multiplicativa a uno de complejidad sumatoria. ¡Es la diferencia entre que un proceso tarde horas o milisegundos!

Pilas (Stacks)

Las Pilas (Stacks) son una estructura de datos abstracta y altamente restrictiva. A diferencia de un Array normal donde puedes leer o insertar en cualquier parte, en un Stack las reglas son estrictas.

Se rigen bajo el principio LIFO (Last In, First Out): el último elemento en entrar es el primero en salir. Imagínalo como una pila de platos en un restaurante, solo puedes interactuar con el plato de arriba.

flowchart TD
 subgraph Pila Stack - LIFO
 direction TB
 E3["[Plato 3] <-- Cima (Peek/Pop)"]
 E2["[Plato 2]"]
 E1["[Plato 1] <-- Base"]
 end

Sus 3 Reglas de Oro:

Los datos solo se pueden insertar al final (Push).
Los datos solo se pueden eliminar del final (Pop).
Solo se puede leer el último elemento (Peek o Cima).

¿Por qué usar una estructura tan restrictiva? Porque nos da seguridad. Al restringir las operaciones de acceso, garantizamos que nadie pueda corromper el orden de los datos intermedios. Es el motor detrás del botón “Deshacer” (Ctrl+Z) de tu editor de texto y del Call Stack de tu procesador.

Colas (Queues)

Las Colas (Queues) son la contraparte directa del Stack. Representan fielmente la fila de un banco o supermercado.

Se rigen por el principio FIFO (First In, First Out): el primer elemento en llegar es el primero en ser atendido.

flowchart LR
 subgraph Cola Queue - FIFO
 direction LR
 S1["[Cliente 1] En cabeza (Atender/Dequeue)"] --> S2["[Cliente 2]"] --> S3["[Cliente 3] En cola (Llegada/Enqueue)"]
 end

Sus 3 Reglas de Oro:

Los datos solo se insertan al final (Enqueue).
Los datos solo se eliminan del inicio (Dequeue).
Solo se puede leer el elemento del inicio.

Casos de uso comunes:

Colas de impresión: los documentos se imprimen exactamente en el orden en que fueron enviados.
Gestión de tareas asíncronas en servidores web (Message Queues).
Procesos de background en sistemas operativos.

Entendiendo la Notación Big O y los Algoritmos de Ordenamiento Básicos

Dacadev — Mon, 18 May 2026 00:00:00 -0500

Tabla de Contenido

¿Cómo podemos comparar dos algoritmos de manera formal? En el post anterior, vimos que contar los segundos es una mala idea porque depende del hardware. Aprendimos que contar los pasos es el camino correcto.

Hoy aprenderemos a usar la Notación Big O, el estándar que usamos en la industria para catalogar la eficiencia del software, y la aplicaremos analizando tres algoritmos de ordenamiento clásicos: Bubble Sort, Selection Sort e Insertion Sort.

¿Qué es la Notación Big O?

La Notación Big O es una herramienta matemática que describe la eficiencia de un algoritmo en función de cómo crece su número de pasos a medida que el tamaño de los datos de entrada (denotado como N) aumenta.

No nos dice la cantidad exacta de milisegundos que tardará un programa, sino la relación de crecimiento entre el volumen de datos y el esfuerzo del procesador.

Los tres perfiles más comunes que hemos visto hasta ahora son:

O(1) - Tiempo Constante: El algoritmo siempre requiere la misma cantidad de pasos, sin importar si N es 10 o 10 millones (por ejemplo, leer un índice en un Array).
O(N) - Tiempo Lineal: El número de pasos crece en proporción directa a los datos (por ejemplo, buscar un elemento mediante Búsqueda Lineal).
O(log N) - Tiempo Logarítmico: El algoritmo es sumamente eficiente. Cada vez que duplicamos los datos, solo se agrega un paso más al total (por ejemplo, la Búsqueda Binaria).

Note

Nota matemática: El logaritmo usado en Big O es en base 2 (log₂ N), no en base 10. Representa cuántas veces puedes dividir N a la mitad antes de llegar a 1.

Veamos gráficamente cómo se comparan estas curvas de crecimiento:

flowchart TD
 subgraph Eficiencia de Algoritmos
 direction TB
 C1["Excelente: O(1)"]
 C2["Muy Bueno: O(log N)"]
 C3["Aceptable: O(N)"]
 C4["Ineficiente: O(N²)"]
 end

Curvas de crecimiento de Big O

1. Ordenamiento Burbuja (Bubble Sort)

Bubble Sort es uno de los algoritmos de ordenamiento más simples e intuitivos. Se llama “Burbuja” porque los valores más altos van “flotando” gradualmente hacia el final del arreglo, como burbujas en el agua.

El proceso paso a paso:

Apuntas a los dos primeros elementos consecutivos del arreglo.
Si el de la izquierda es mayor que el de la derecha, los intercambias (swap).
Mueves los punteros una celda a la derecha y repites la comparación.
Repites el proceso hasta llegar al final del arreglo. Al terminar esta primera pasada, el número más alto está garantizado a estar en la última celda.
Regresas al inicio y realizas otra pasada completa.
El proceso termina cuando completas una pasada entera sin realizar ningún intercambio, lo que significa que todo está perfectamente ordenado.

flowchart TD
 Start["[4, 2, 7, 1]"] --> Step1["Comparar 4 y 2 -> ¡Intercambiar!"]
 Step1 --> Step2["[2, 4, 7, 1]"]
 Step2 --> Step3["Comparar 4 y 7 -> No intercambiar"]
 Step3 --> Step4["[2, 4, 7, 1]"]
 Step4 --> Step5["Comparar 7 y 1 -> ¡Intercambiar!"]
 Step5 --> EndPass["[2, 4, 1, 7] -> Primera pasada completada (7 está ordenado)"]

Implementación en Python:

def bubble_sort(arr: list[int]) -> list[int]:
 unsorted_until_index: int = len(arr) - 1
 is_sorted: bool = False

 while not is_sorted:
 is_sorted = True
 for i in range(unsorted_until_index):
 if arr[i] > arr[i+1]:
 # Intercambio rápido en Python:
 arr[i], arr[i+1] = arr[i+1], arr[i]
 is_sorted = False
 unsorted_until_index -= 1

 return arr

Eficiencia de Bubble Sort

Para ordenar un arreglo de tamaño N, en el peor de los casos realizamos aproximadamente N² comparaciones e intercambios.

Complejidad: O(N²) o Tiempo Cuadrático.
Veredicto: Altamente ineficiente para grandes conjuntos de datos. A medida que N se duplica, el número de pasos se multiplica por cuatro.

2. Ordenamiento por Selección (Selection Sort)

Selection Sort toma un camino diferente: en lugar de ir comparando parejas consecutivas, realiza una pasada completa para “seleccionar” el elemento más pequeño del arreglo y colocarlo en su posición final.

El proceso paso a paso:

Comienzas en el índice 0. Recorres todo el arreglo buscando el valor más pequeño.
Al terminar la pasada, intercambias el valor más pequeño con el elemento en el índice 0.
Te mueves al índice 1 y repites el proceso buscando el menor valor del resto del arreglo.
Repites esto aumentando el índice de inicio en 1 cada vez, hasta llegar al final.

flowchart TD
 Start["[4, 2, 7, 1]"] --> Step1["Buscar el menor desde índice 0 -> Es 1"]
 Step1 --> Swap1["Intercambiar 1 (menor) con 4 (índice 0)"]
 Swap1 --> Step2["[1, 2, 7, 4]"]
 Step2 --> Step3["Buscar el menor desde índice 1 -> Es 2"]
 Step3 --> Swap2["2 ya está en su lugar -> No hay cambios"]
 Swap2 --> Step4["[1, 2, 7, 4]"]
 Step4 --> Step5["Buscar el menor desde índice 2 -> Es 4"]
 Step5 --> Swap3["Intercambiar 4 con 7 (índice 2)"]
 Swap3 --> End["[1, 2, 4, 7] -> ¡Completamente Ordenado! 🎉"]

Implementación en Python:

def selection_sort(arr: list[int]) -> list[int]:
 for i in range(len(arr) - 1):
 lowest_number_index: int = i
 for j in range(i + 1, len(arr)):
 if arr[j] < arr[lowest_number_index]:
 lowest_number_index = j

 if lowest_number_index != i:
 arr[i], arr[lowest_number_index] = arr[lowest_number_index], arr[i]

 return arr

Eficiencia de Selection Sort

Si contamos los pasos de Selection Sort, en promedio realiza unas N²/2 comparaciones. Sin embargo, dado que Big O elimina las constantes (las fracciones y multiplicaciones por números fijos), su complejidad teórica también queda como O(N²).

Tip

¿Selection Sort o Bubble Sort? Aunque ambos son categorizados bajo el mismo grupo O(N²), Selection Sort es aproximadamente el doble de rápido en la vida real porque realiza un máximo de N intercambios, mientras que Bubble Sort puede realizar hasta N² intercambios.

3. Optimizando para Escenarios Optimistas (Insertion Sort)

Hasta ahora hemos analizado el rendimiento basándonos en el peor caso posible. Pero en el desarrollo real, muchas veces nos encontramos con arreglos que ya están parcialmente ordenados. Aquí es donde brilla Insertion Sort.

Insertion Sort funciona de manera similar a como ordenarías un mazo de cartas en tu mano.

El proceso paso a paso:

Comienzas en el índice 1 (la segunda celda). Remueves temporalmente el valor y lo guardas en una variable temporal (temp), dejando un “hueco”.
Comparas cada elemento a la izquierda del hueco con el valor en temp.
Si el elemento de la izquierda es mayor que temp, lo desplazas una posición hacia la derecha (el hueco se mueve hacia la izquierda).
Repites el paso 3 hasta encontrar un elemento menor o igual a temp, o llegar al inicio del arreglo.
Colocas el valor de temp en el hueco actual.
Repites el ciclo avanzando al siguiente índice.

Implementación en Python:

def insertion_sort(arr: list[int]) -> list[int]:
 for index in range(1, len(arr)):
 temp_value: int = arr[index]
 position: int = index - 1

 while position >= 0:
 if arr[position] > temp_value:
 arr[position + 1] = arr[position]
 position -= 1
 else:
 break

 arr[position + 1] = temp_value

 return arr

La gran revelación: El impacto de los escenarios

Analicemos la eficiencia de los tres algoritmos comparando sus mejores, peores y promedio casos:

Algoritmo	Peor Caso (Worst Case)	Caso Promedio (Average)	Mejor Caso (Best Case)
Bubble Sort	O(N²)	O(N²)	O(N) (si ya está ordenado)
Selection Sort	O(N²)	O(N²)	O(N²)
Insertion Sort	O(N²)	O(N²)	O(N)

¿Por qué Insertion Sort es tan especial?

Si le pasamos un arreglo que ya está ordenado a Insertion Sort, el bucle while interno se rompe inmediatamente en el primer paso (break). No hace ningún desplazamiento de datos. Por lo tanto, se ejecuta en un espectacular tiempo lineal O(N).

Si tus datos están mayoritariamente ordenados, Insertion Sort es por mucho la mejor opción entre los ordenamientos básicos.

Estructuras de Datos y Algoritmos: Los Fundamentos que Todo Dev Debe Saber

Dacadev — Sun, 17 May 2026 00:00:00 -0500

Tabla de Contenido

Si estás dando tus primeros pasos en el desarrollo de software, es muy común que midas el éxito de tu código con una única pregunta: ¿funciona y hace lo que se supone que debe hacer?

Sin embargo, a medida que avanzas en tu carrera, te das cuenta de que existe un mundo entero de otras métricas críticas, como por ejemplo: ¿Qué tan rápido se ejecuta? ¿Cuánta memoria consume? ¿Es escalable si el volumen de datos crece por mil?

Para escribir código que no solo funcione sino que sea verdaderamente profesional, debes dominar dos pilares fundamentales: las estructuras de datos y los algoritmos. Empecemos por lo básico: ¿qué son y por qué importan?

¿Por qué importa la estructura?

Consideremos una tarea sencilla: escribir una función en Python que imprima todos los números pares del 2 al 100.

Aquí tienes la versión uno (menos eficiente):

def print_numbers_version_one():
 number = 2

 while number <= 100:
 # Si el número es par, lo imprimimos:
 if number % 2 == 0:
 print(number)

 number += 1

Y aquí tienes la versión dos (más eficiente):

def print_numbers_version_two():
 number = 2

 while number <= 100:
 print(number)

 # Incrementamos por 2 directo al siguiente número par:
 number += 2

Ambos programas producen exactamente el mismo resultado. Pero la versión uno realiza 100 iteraciones y comprueba la paridad en cada paso. La versión dos solo hace 50 iteraciones y no realiza comprobaciones matemáticas innecesarias. Es el doble de eficiente.

¿Qué es una Estructura de Datos?

Una estructura de datos es la manera física y lógica en la que organizamos, gestionamos y almacenamos los datos en nuestro código. La forma en que eliges organizar tus datos afecta directamente la rapidez con la que tu programa puede operar con ellos.

Para un mismo propósito, puedes usar diferentes estructuras. Por ejemplo, si deseas unir tres palabras:

# Usando variables simples
x = "¡Hola! "
y "¿Cómo estás "
z = "hoy?"
print(x + y + z)

# Usando un Array (o Lista en Python)
array = ["¡Hola! ", "¿Cómo estás ", "hoy?"]
print(array[0] + array[1] + array[2])

Midiendo la velocidad del código

Un error clásico es medir la velocidad de un programa cronometrando los segundos que tarda en completarse. No es la mejor manera, El tiempo de ejecución en segundos varía según:

El procesador y hardware de la máquina.
Qué otros programas se están ejecutando en segundo plano.
El lenguaje de programación y su compilador o intérprete.

Para medir la velocidad de manera científica y objetiva, contamos la cantidad de pasos físicos que requiere un algoritmo para completarse.

El Array

El Array (o arreglo) es la estructura de datos más básica y el punto de partida de casi todo en computación. Físicamente, un array es un bloque continuo de memoria.

Un array tiene dos características clave:

Tamaño (Size): El número total de elementos que contiene.
Índice (Index): La posición numérica de cada celda. En la gran mayoría de lenguajes de programación, empezamos a contar desde 0.

array = ["manzanas", "bananas", "pepinos", "dátiles", "arándanos"]

Podemos representar la memoria de un array así:

flowchart LR
 a0["[0] manzanas
Mem: 1000"]
 a1["[1] bananas
Mem: 1001"]
 a2["[2] pepinos
Mem: 1002"]
 a3["[3] dátiles
Mem: 1003"]
 a4["[4] arándanos
Mem: 1004"]
 a0 --- a1 --- a2 --- a3 --- a4

Las 4 Operaciones Fundamentales en un Array

Para evaluar qué tan eficiente es una estructura de datos, analizamos cuántos pasos le toma realizar las cuatro operaciones básicas:

1. Lectura (Read / Get)

Consiste en obtener el valor que está en un índice específico (por ejemplo, “¿qué hay en la posición 3?”).

¿Cómo lo hace la computadora? Al estar guardados en memoria de manera continua, la computadora hace un cálculo matemático simple: DirecciónInicio + (Índice * TamañoCelda). Va directo a la celda en 1 paso.
Eficiencia: 1 paso (constante).

2. Búsqueda (Search)

Consiste en encontrar el índice de un elemento sabiendo únicamente su valor (por ejemplo, “¿en qué posición están los ‘pepinos’?”).

¿Cómo lo hace? La computadora no puede ver el contenido de todo el array a la vez. Debe ir celda por celda, de izquierda a derecha, comprobando si el valor coincide. A esto se le llama Búsqueda Lineal.
Eficiencia: Si el elemento está al principio, toma 1 paso. Si está al final o no existe, toma N pasos (siendo N el tamaño del array). En el peor de los casos, la eficiencia es de N pasos.

3. Inserción (Insert)

Consiste en agregar un nuevo elemento al array. Aquí tenemos dos escenarios:

Insertar al final: Es súper sencillo. La computadora simplemente coloca el valor en la siguiente celda libre. Toma 1 paso.
Insertar al inicio o en medio: ¡Aquí viene el dolor de cabeza! Para meter un valor al inicio (índice 0), primero debemos mover todos los elementos existentes una celda hacia la derecha para abrir espacio.

flowchart TD
 subgraph Antes de Insertar
 A0["[0] A"] --> A1["[1] B"] --> A2["[2] C"]
 end
 subgraph Proceso de Desplazamiento
 D0["Desplazar C a [3]"] --> D1["Desplazar B a [2]"] --> D2["Desplazar A a [1]"]
 end
 subgraph Resultado Final
 R0["[0] NUEVO"] --> R1["[1] A"] --> R2["[2] B"] --> R3["[3] C"]
 end

Si el array tiene tamaño N, insertar al principio toma N desplazamientos + 1 inserción = N + 1 pasos.

4. Eliminación (Delete)

Consiste en borrar un elemento de un índice específico. Al igual que con la inserción, si borramos el elemento del inicio, dejamos un “hueco vacío”. Las reglas de los arrays exigen que no haya espacios vacíos intermedios, por lo que debemos desplazar todos los elementos de la derecha una posición hacia la izquierda.

Eficiencia: En el peor de los casos (eliminar el primer elemento), toma N - 1 pasos de desplazamiento.

Sets: Cómo una sola regla cambia toda la eficiencia

Un Set (conjunto) es un tipo especial de arreglo con una regla estricta: no se permiten valores duplicados.

Esta pequeña regla de negocio transforma drásticamente la eficiencia de la operación de inserción:

En un Array común, insertar al final toma 1 paso.
En un Set, antes de insertar un elemento al final, la computadora debe hacer una búsqueda lineal completa para asegurar que el elemento no exista previamente en el Set.

Por lo tanto, la inserción al final en un Set toma N pasos de búsqueda + 1 paso de inserción = N + 1 pasos.

Note

Aunque los Sets protegen la integridad de tus datos previniendo duplicados, debes tener en cuenta que su inserción es mucho más lenta en arreglos de gran tamaño.

Arreglos Ordenados

Un Arreglo Ordenado es un array cuyos valores se mantienen de forma ascendente o descendente de forma obligatoria.

Inserción en Arreglos Ordenados

Para insertar un valor en un arreglo ordenado (por ejemplo, meter el número 4 en [1, 3, 5, 8]), no podemos simplemente agregarlo al final. Debemos:

Buscar el lugar exacto donde corresponde el elemento para mantener el orden (después del 3 y antes del 5).
Desplazar los elementos mayores hacia la derecha (5 y 8).
Insertar el nuevo valor.

Esto hace que la inserción sea ligeramente más costosa en pasos que en un array normal, pero abre la puerta a un algoritmo de búsqueda revolucionario.

Búsqueda Binaria

Si tu arreglo no está ordenado, la única forma de buscar es la búsqueda lineal (celda por celda), lo que toma hasta N pasos.

Pero si tu arreglo sí está ordenado, puedes usar la Búsqueda Binaria. Este algoritmo consiste en:

Ir directo al elemento del medio del arreglo.
Si el valor buscado es menor, descartas toda la mitad derecha.
Si es mayor, descartas toda la mitad izquierda.
Repites el proceso en la mitad restante hasta encontrarlo o quedarte sin elementos.

flowchart TD
 Start["Buscar 11 en [2, 4, 6, 8, 11, 14, 18, 22]"] --> Step1["Valor central: 8 (índice 3)"]
 Step1 --> Check{"¿Es 11 == 8?"}
 Check -- No, es mayor --> DescartarIzq["Descartar [2, 4, 6, 8]"]
 DescartarIzq --> SubSearch["Buscar en [11, 14, 18, 22]"]
 SubSearch --> Step2["Valor central: 14 (índice 5)"]
 Step2 --> Check2{"¿Es 11 == 14?"}
 Check2 -- No, es menor --> DescartarDer["Descartar [14, 18, 22]"]
 DescartarDer --> Final["Buscar en [11] -> ¡Encontrado! 🎉"]

Búsqueda Binaria vs. Búsqueda Lineal

Tamaño del Arreglo (N)	Pasos Máximos (Lineal)	Pasos Máximos (Binaria)
8	8	3
100	100	7
10,000	10,000	14
1,000,000	1,000,000	20

La diferencia es notable. Buscar en una base de datos de un millón de registros toma un millón de pasos con búsqueda lineal, pero solo 20 pasos usando búsqueda binaria. Por eso, elegir el algoritmo correcto de acuerdo a la estructura de tus datos marca toda la diferencia del mundo.

En el siguiente post, aprenderemos la forma matemática formal en la que los desarrolladores expresamos estas diferencias de eficiencia: la Notación Big O, y cómo usarla para analizar nuestros primeros algoritmos de ordenamiento. ¡No te lo pierdas! 🚀