Los algoritmos de ordenación son fundamentales en programación. Su objetivo es reorganizar los elementos de una lista según un criterio (generalmente de menor a mayor). En este artículo comparamos los tres más usados.
Bubble Sort — El más sencillo
Bubble Sort compara pares de elementos adyacentes y los intercambia si están en el orden incorrecto. Repite este proceso hasta que la lista esté ordenada.
def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
return arr
print(bubble_sort([64, 34, 25, 12, 22]))
# Output: [12, 22, 25, 34, 64]Complejidad: O(n²) en el peor caso. No es eficiente para listas grandes, pero es fácil de entender.
Quick Sort — El más rápido en la práctica
Quick Sort elige un elemento pivote y divide la lista en dos partes: los menores que el pivote y los mayores. Luego ordena cada parte recursivamente.
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
print(quick_sort([3, 6, 8, 10, 1, 2, 1]))
# Output: [1, 1, 2, 3, 6, 8, 10]Complejidad: O(n log n) de media. Es uno de los más rápidos en la práctica para listas grandes.
Merge Sort — El más estable
Merge Sort divide la lista por la mitad repetidamente hasta tener sublistas de un elemento, luego las fusiona en orden.
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
def merge(left, right):
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i]); i += 1
else:
result.append(right[j]); j += 1
return result + left[i:] + right[j:]Complejidad: O(n log n) siempre. Es más consistente que Quick Sort pero usa más memoria.
¿Cuál elegir?
| Algoritmo | Peor caso | Mejor caso | Estable |
|---|---|---|---|
| Bubble Sort | O(n²) | O(n) | Sí |
| Quick Sort | O(n²) | O(n log n) | No |
| Merge Sort | O(n log n) | O(n log n) | Sí |