Buscar y ordenar datos son dos tareas fundamentales en programación. Aunque Python incluye herramientas listas para usar, entender cómo funcionan los algoritmos clásicos ayuda a mejorar la lógica, comprender la eficiencia y resolver problemas de forma más consciente.
En esta guía vamos a implementar paso a paso algoritmos de búsqueda y ordenamiento en Python, incluyendo búsqueda lineal, búsqueda binaria, burbuja, selección e inserción.
Idea clave: aprender estos algoritmos no significa que debamos programarlos manualmente cada vez. Python ya ofrece herramientas eficientes, pero conocer su lógica interna es fundamental para aprender estructuras de datos y análisis de algoritmos.
¿Qué significa buscar y ordenar?
Buscar significa localizar un dato dentro de una colección.
Ordenar significa reorganizar los elementos según algún criterio, por ejemplo de menor a mayor, de mayor a menor o alfabéticamente.
numeros = [8, 3, 10, 1, 6]
Ordenada de menor a mayor:
[1, 3, 6, 8, 10]
Búsqueda lineal
La búsqueda lineal recorre los elementos uno por uno hasta encontrar el valor buscado.
def busqueda_lineal(lista, buscado):
for i in range(len(lista)):
if lista[i] == buscado:
return i
return -1
numeros = [10, 20, 30, 40]
posicion = busqueda_lineal(numeros, 30)
print(posicion)
El resultado será 2, porque Python comienza a contar las posiciones desde 0.
Búsqueda binaria
La búsqueda binaria es más eficiente para listas grandes, pero tiene una condición fundamental:
la lista debe estar ordenada.
def busqueda_binaria(lista, buscado):
izquierda = 0
derecha = len(lista) - 1
while izquierda <= derecha:
medio = (izquierda + derecha) // 2
if lista[medio] == buscado:
return medio
if lista[medio] < buscado:
izquierda = medio + 1
else:
derecha = medio - 1
return -1
numeros = [10, 20, 30, 40, 50]
print(busqueda_binaria(numeros, 40))
Ordenamiento burbuja
El método burbuja compara pares de elementos consecutivos y los intercambia cuando están en el orden incorrecto.
def burbuja(lista):
resultado = lista.copy()
for i in range(len(resultado) - 1):
for j in range(len(resultado) - 1 - i):
if resultado[j] > resultado[j + 1]:
resultado[j], resultado[j + 1] = resultado[j + 1], resultado[j]
return resultado
numeros = [8, 3, 10, 1, 6]
print(burbuja(numeros))
Ordenamiento por selección
Selección busca el menor elemento de la parte desordenada y lo coloca en la posición correspondiente.
def seleccion(lista):
resultado = lista.copy()
for i in range(len(resultado) - 1):
posicion_menor = i
for j in range(i + 1, len(resultado)):
if resultado[j] < resultado[posicion_menor]:
posicion_menor = j
resultado[i], resultado[posicion_menor] = resultado[posicion_menor], resultado[i]
return resultado
numeros = [8, 3, 10, 1, 6]
print(seleccion(numeros))
Ordenamiento por inserción
Inserción toma cada elemento y lo coloca en su posición correcta dentro de la parte ya ordenada.
def insercion(lista):
resultado = lista.copy()
for i in range(1, len(resultado)):
actual = resultado[i]
j = i - 1
while j >= 0 and resultado[j] > actual:
resultado[j + 1] = resultado[j]
j -= 1
resultado[j + 1] = actual
return resultado
numeros = [8, 3, 10, 1, 6]
print(insercion(numeros))
Herramientas nativas de Python
En programas reales normalmente utilizaremos herramientas incorporadas.
Buscar con in
numeros = [10, 20, 30]
if 20 in numeros:
print("Encontrado")
Obtener la posición con index()
numeros = [10, 20, 30]
posicion = numeros.index(20)
print(posicion)
Ordenar con sorted()
numeros = [8, 3, 10, 1]
ordenados = sorted(numeros)
print(ordenados)
Ordenar la lista original con sort()
numeros = [8, 3, 10, 1]
numeros.sort()
print(numeros)
sorted() vs sort()
sorted() devuelve una nueva lista y deja la original sin cambios.
sort() modifica directamente la lista.
numeros = [3, 1, 2]
ordenados = sorted(numeros)
print(numeros)
print(ordenados)
¿Para qué aprender estos algoritmos si Python ya tiene sorted() e in?
Porque programar no consiste solamente en conocer funciones existentes. Implementar estos algoritmos permite entender:
- cómo se recorren estructuras de datos;
- cómo se comparan valores;
- cómo se intercambian elementos;
- cómo influye el orden de los datos;
- por qué algunos algoritmos son más rápidos que otros;
- cómo dividir un problema en pasos;
- qué ocurre internamente cuando buscamos u ordenamos información.
En aplicaciones reales normalmente elegiremos las herramientas nativas de Python, que están altamente optimizadas. Pero estudiar los algoritmos manualmente desarrolla habilidades que se aplican mucho más allá de este tema.
Una introducción a la complejidad
La complejidad describe cómo crece el trabajo que realiza un algoritmo cuando aumenta la cantidad de datos.
Sin entrar todavía en un análisis matemático profundo:
- la búsqueda lineal puede necesitar revisar todos los elementos;
- la búsqueda binaria descarta aproximadamente la mitad de los elementos en cada paso;
- burbuja, selección e inserción pueden realizar muchas comparaciones cuando la lista crece.
Más adelante este concepto se estudia formalmente mediante notaciones como O(n), O(log n) y O(n²).
Índice de ejercicios
- Búsqueda lineal
- Búsqueda lineal devolviendo posición
- Buscar un nombre
- Búsqueda binaria
- Burbuja ascendente
- Burbuja descendente
- Ordenamiento por selección
- Ordenamiento por inserción
- Ordenar nombres
- Ordenar notas
- Eliminar duplicados y ordenar
- Buscar máximo y mínimo
- Comparar búsqueda manual con in
- Comparar burbuja con sorted()
- Función reutilizable de búsqueda
- Función reutilizable de burbuja
- Buscar dentro de nombres
- Ordenar y luego buscar
- Contar comparaciones
- Mini sistema para cargar, ordenar y buscar
1. Búsqueda lineal
numeros = [4, 8, 15, 16, 23, 42]
buscado = 15
encontrado = False
for numero in numeros:
if numero == buscado:
encontrado = True
if encontrado:
print("Encontrado")
else:
print("No encontrado")
2. Búsqueda lineal devolviendo posición
def buscar(lista, buscado):
for i in range(len(lista)):
if lista[i] == buscado:
return i
return -1
numeros = [10, 20, 30, 40]
posicion = buscar(numeros, 30)
if posicion != -1:
print("Encontrado en la posicion", posicion)
else:
print("No encontrado")
3. Buscar un nombre
nombres = ["Ana", "Luis", "Pedro", "Maria"]
buscado = input("Ingrese un nombre: ")
encontrado = False
for nombre in nombres:
if nombre.lower() == buscado.lower():
encontrado = True
if encontrado:
print("Nombre encontrado")
else:
print("Nombre no encontrado")
4. Búsqueda binaria
def busqueda_binaria(lista, buscado):
izquierda = 0
derecha = len(lista) - 1
while izquierda <= derecha:
medio = (izquierda + derecha) // 2
if lista[medio] == buscado:
return medio
if lista[medio] < buscado:
izquierda = medio + 1
else:
derecha = medio - 1
return -1
numeros = [2, 5, 8, 12, 16, 20, 25]
print(busqueda_binaria(numeros, 16))
5. Burbuja ascendente
numeros = [5, 2, 8, 1, 4]
for i in range(len(numeros) - 1):
for j in range(len(numeros) - 1 - i):
if numeros[j] > numeros[j + 1]:
numeros[j], numeros[j + 1] = numeros[j + 1], numeros[j]
print(numeros)
6. Burbuja descendente
numeros = [5, 2, 8, 1, 4]
for i in range(len(numeros) - 1):
for j in range(len(numeros) - 1 - i):
if numeros[j] < numeros[j + 1]:
numeros[j], numeros[j + 1] = numeros[j + 1], numeros[j]
print(numeros)
7. Ordenamiento por selección
numeros = [9, 3, 7, 1, 5]
for i in range(len(numeros) - 1):
menor = i
for j in range(i + 1, len(numeros)):
if numeros[j] < numeros[menor]:
menor = j
numeros[i], numeros[menor] = numeros[menor], numeros[i]
print(numeros)
8. Ordenamiento por inserción
numeros = [9, 3, 7, 1, 5]
for i in range(1, len(numeros)):
actual = numeros[i]
j = i - 1
while j >= 0 and numeros[j] > actual:
numeros[j + 1] = numeros[j]
j -= 1
numeros[j + 1] = actual
print(numeros)
9. Ordenar nombres
nombres = ["Pedro", "Ana", "Luis", "Maria"]
ordenados = sorted(nombres)
print(ordenados)
10. Ordenar notas
notas = [7.5, 9, 6, 8.5, 10]
notas.sort(reverse=True)
print(notas)
11. Eliminar duplicados y ordenar
numeros = [5, 2, 5, 8, 2, 1, 8]
sin_duplicados = []
for numero in numeros:
if numero not in sin_duplicados:
sin_duplicados.append(numero)
sin_duplicados.sort()
print(sin_duplicados)
12. Buscar máximo y mínimo
numeros = [8, 3, 15, 2, 11]
mayor = numeros[0]
menor = numeros[0]
for numero in numeros:
if numero > mayor:
mayor = numero
if numero < menor:
menor = numero
print("Mayor:", mayor)
print("Menor:", menor)
13. Comparar búsqueda manual con in
numeros = [10, 20, 30, 40]
buscado = 30
encontrado_manual = False
for numero in numeros:
if numero == buscado:
encontrado_manual = True
print("Busqueda manual:", encontrado_manual)
print("Usando in:", buscado in numeros)
14. Comparar burbuja con sorted()
original = [8, 3, 10, 1, 6]
burbuja = original.copy()
for i in range(len(burbuja) - 1):
for j in range(len(burbuja) - 1 - i):
if burbuja[j] > burbuja[j + 1]:
burbuja[j], burbuja[j + 1] = burbuja[j + 1], burbuja[j]
nativo = sorted(original)
print("Burbuja:", burbuja)
print("sorted():", nativo)
15. Función reutilizable de búsqueda
def buscar(lista, valor):
for i in range(len(lista)):
if lista[i] == valor:
return i
return -1
datos = [12, 18, 25, 30]
print(buscar(datos, 25))
16. Función reutilizable de burbuja
def ordenar_burbuja(lista):
resultado = lista.copy()
for i in range(len(resultado) - 1):
for j in range(len(resultado) - 1 - i):
if resultado[j] > resultado[j + 1]:
resultado[j], resultado[j + 1] = resultado[j + 1], resultado[j]
return resultado
numeros = [7, 2, 9, 1]
print(ordenar_burbuja(numeros))
17. Buscar dentro de nombres
def buscar_nombre(nombres, buscado):
for i in range(len(nombres)):
if nombres[i].lower() == buscado.lower():
return i
return -1
nombres = ["Ana", "Carlos", "Maria", "Pedro"]
posicion = buscar_nombre(nombres, "maria")
print(posicion)
18. Ordenar y luego buscar
numeros = [30, 10, 50, 20, 40]
numeros.sort()
buscado = 40
izquierda = 0
derecha = len(numeros) - 1
posicion = -1
while izquierda <= derecha and posicion == -1:
medio = (izquierda + derecha) // 2
if numeros[medio] == buscado:
posicion = medio
elif numeros[medio] < buscado:
izquierda = medio + 1
else:
derecha = medio - 1
print("Lista ordenada:", numeros)
print("Posicion:", posicion)
19. Contar comparaciones
numeros = [8, 3, 10, 1, 6]
comparaciones = 0
for i in range(len(numeros) - 1):
for j in range(len(numeros) - 1 - i):
comparaciones += 1
if numeros[j] > numeros[j + 1]:
numeros[j], numeros[j + 1] = numeros[j + 1], numeros[j]
print("Lista:", numeros)
print("Comparaciones:", comparaciones)
20. Mini sistema para cargar, ordenar y buscar
def cargar_numeros():
numeros = []
cantidad = int(input("Cuantos numeros desea cargar: "))
for i in range(cantidad):
numero = int(input("Ingrese un numero: "))
numeros.append(numero)
return numeros
def buscar(lista, valor):
for i in range(len(lista)):
if lista[i] == valor:
return i
return -1
numeros = []
opcion = 0
while opcion != 4:
print("")
print("=== MENU ===")
print("1. Cargar numeros")
print("2. Ordenar")
print("3. Buscar")
print("4. Salir")
opcion = int(input("Seleccione una opcion: "))
if opcion == 1:
numeros = cargar_numeros()
print("Datos cargados:", numeros)
elif opcion == 2:
numeros.sort()
print("Lista ordenada:", numeros)
elif opcion == 3:
valor = int(input("Valor a buscar: "))
posicion = buscar(numeros, valor)
if posicion != -1:
print("Encontrado en la posicion", posicion)
else:
print("No encontrado")
elif opcion == 4:
print("Programa finalizado")
else:
print("Opcion invalida")
Errores comunes
- Aplicar búsqueda binaria sobre una lista desordenada.
- Olvidar que los índices comienzan en 0.
- Confundir
sorted() con sort().
- No conservar una copia cuando queremos mantener la lista original.
- Usar
index() sin verificar si el valor existe.
- Implementar manualmente algoritmos en producción cuando una herramienta nativa resuelve mejor el problema.
Qué aprendimos
Con estos ejercicios practicamos búsquedas, comparaciones, intercambios, ciclos anidados, funciones y manejo de listas.
También vimos una idea importante: conocer el algoritmo y saber cuándo usar una herramienta nativa son habilidades complementarias.
Próximo paso: proyecto final en Python
Ya trabajamos variables, tipos de datos, condicionales, ciclos, listas, funciones, búsqueda y ordenamiento. El siguiente paso será combinar todos estos conceptos en un proyecto completo en Python.
Seguí aprendiendo Python
Si querés repasar cómo organizar estos algoritmos en bloques reutilizables, consultá Funciones en Python.
Con búsqueda y ordenamiento ya tenemos las piezas principales para cerrar esta primera ruta:
Proyecto final en Python: sistema de gestión de alumnos paso a paso →
Ver la ruta completa de Python
¿Te sirvió esta guía? ☕
Si este contenido te ayudó a aprender Python, podés apoyar a Club Programador. Cada aporte ayuda a mantener el sitio online y a seguir publicando material gratuito.
🇦🇷 Apoyar desde Argentina
☕ Invitame un café con Mercado Pago
🌎 Apoyar desde otro país
☕ Apoyar con PayPal
