Semana 5 Algoritmos Ordenamiento y Búsqueda

1. ALGORITMOS DE
ORDENAMIENTO
CON PYTHON
Mg. Richard E. Mendoza G.

4. https://www.youtube.com/watch?v=gUjXiYtOC7Y

5. https://www.youtube.com/watch?v=lyZQPjUT5B4

7. https://forbes.co/2020/10/21/emprendedores/las-10-startups-que-hacen-
parte-la-cuarta-generacion-de-rockstart-latam/

8. ¿Qué es un algoritmo de
ordenamiento?
Son estos algoritmos que se
encargan de dar un orden a un set
de datos (números o letras).
¿Qué es orden?
Un orden dado o especifico.
Generalmente en estos algoritmos
se genera por un arreglo(Array).
Algoritmos de Ordenamiento
vector1=['d','c','b','a']
print(vector1)
print(vector1.sort())
vector2=[5,4,3,2,1]
print(vector2)
print(vector2.sort())
['a','b','c','d'] #arreglo ordenado alfa
béticamente.
[1,2,3,4,5] #un arreglo de números enter
os en orden ascendente.

11. ⚫Determinar con exactitud el origen del ordenamiento
burbuja es un poco complicado, ya que no existe
información precisa sobre su origen.
⚫Aunque en 1956 se encuentra expresado en un articulo
al que llamaron “ordenamiento por intercambio”
⚫Existe una amplia bibliografía de artículos del año 1962
donde mencionan tipos de ordenamiento basados en
este patrón, pero ninguno de ellos usando el nombre
como tal.
Historia

12. ⚫Sin evidente origen definitivo del nombre "burbuja“ se
cierran sus orígenes mediante la consulta de los
primeros artículos de revistas así como textos
profesionales y pedagógicos de esta época.
⚫Obtiene su nombre de la forma con la que suben por la
lista los elementos durante los intercambios, como si
fueran pequeñas "burbujas".
⚫También es conocido como el método del
intercambio directo. Dado que solo usa comparaciones
para operar elementos, se lo considera un algoritmo de
comparación, siendo el más sencillo de implementar.
Historia

13. La Ordenación de burbuja funciona
revisando cada elemento de la lista
que va a ser ordenada con el
siguiente, intercambiándolos de
posición si están en el orden
equivocado. Es necesario revisar
varias veces toda la lista hasta que
no se necesiten más intercambios, lo
cual significa que la lista está
ordenada.
Bubble Sort

14. Bubble Sort

15. Ventajas:
● Eficaz
● Sencillo
● Codigo reducido para realizar el
ordenamiento
Desventajas:
● Consume bastante tiempo de
computadora
● Requiere muchas
lecturas/escrituras en memoria
Ventajas y Desventajas

16. A[0] A[1] A[2] A[3] A[4] cont1 cont2
15 4 18 27 6
vector[cont2] vector[cont2+1] temporal
Algoritmo OrdenamientoBubbleSort
Escribir 'Programa Ordenamiento Intercambio Directo o Burbuja’
Escribir 'Digite tamaño del vector’
Leer tamanio
Dimension vector[tamanio]
Para conta_i←1 Hasta tamanio Con Paso 1 Hacer
Escribir 'Digite los elementos:’
Leer elemento vector[conta_i]=elemento
Fin Para
Escribir 'Vector Original:’
Para conta_i←1 Hasta tamanio Con Paso 1 Hacer
Escribir vector[conta_i]
Fin Para
Para conta_i←2 Hasta tamanio Con Paso 1 Hacer
Para conta_j←1 Hasta tamanio-1 Con Paso 1 Hacer
Si vector[conta_j]>vector[conta_j+1] Entonces
temporal←vector[conta_j]
vector[conta_j]←vector[conta_j+1]
vector[conta_j+1]←temporal
Fin Si
Fin Para
Fin Para
Escribir 'Vector Ordenado:’
Para conta_i←1 Hasta tamanio Con Paso 1 Hacer
Escribir vector[conta_i]
Fin Para
FinAlgoritmo

17. #ORDENAMIENTO INTERCAMBIO O BURBUJA
print('Programa Ordenamiento Burbuja')
vector=[]
for cont1 in range(0,5):
elemento=int(input('Digite elemento del vector:'))
vector.append(elemento)
print(vector)
for cont2 in range(1,5):
for cont3 in range(0,4):
if vector[cont3]>vector[cont3+1]:
temporal=vector[cont3]
vector[cont3]=vector[cont3+1]
vector[cont3+1]=temporal
print(vector)

18. En el contexto de un arreglo, el
proceso de este algoritmo consiste
en buscar el menor elemento e
intercambiarlo por el elemento en la
primera posición. Luego se busca el
segundo elemento más pequeño del
arreglo y se intercambia con el
elemento de la segunda posición. El
proceso continúa hasta que todos los
elementos del arreglo hayan sido
ordenados.
Selection Sort

19. Seleccionamos la primera posición del arreglo, que es donde comenzaremos la
lista ordenada; en el ejemplo, el valor en esa posición es el 15. Recorremos toda
la lista y nos damos cuenta de que el elemento menor es el 10, como lo vemos
en la siguiente imagen.
Selection Sort
Una vez ubicados, la primera posición del arreglo y el elemento menor de la lista, los
intercambiamos de lugar. Lo anterior da como resultado que el elemento más bajo quede
en la primera posición de la lista.
Se localiza la segunda posición del arreglo (abajo de color amarillo), así como el siguiente
elemento menor (abajo de color rojo), y los intercambiamos como lo hicimos en el
ordenamiento anterior.

20. A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7]
15 33 27 10 35 19 42 44
Conta_i Conta_j Indice_k Intervalo Tamanio
Algoritmo OrdenamientoSeleccion
Escribir 'Programa Ordenamiento Selección’
Escribir 'Digite tamaño del vector:’
Leer tamanio
Dimension vector[tamanio]
Para conta_i←1 Hasta tamanio Con Paso 1 Hacer
Escribir 'Digite los elementos del vector:’
Leer elemento vector[conta_i]←elemento
Fin Para
Para conta_i←1 Hasta tamanio Con Paso 1 Hacer
Escribir vector[conta_i]
Fin Para
Para conta_i←1 Hasta tamanio-1 Con Paso 1 Hacer
temporal←vector[conta_i]-intervalo
indice_k←conta_i
Para conta_j←conta_i+1 Hasta tamanio Con Paso 1 Hacer
Si vector[conta_j]<temporal Entonces
temporal←vector[conta_j]
indice_k←conta_j
FinSi
Fin Para
vector[indice_k]←vector[conta_i]
vector[conta_i]←temporal
Fin Para
Para conta_i←1 Hasta tamanio Con Paso 1 Hacer
Escribir vector[conta_i]
Fin Para
FinAlgoritmo

21. print('Programa Ordenamiento Selection Sort')
tamanio=int(input('Digite tamaño del vector:'))
vector=[]
for conta_i in range(0,tamanio):
elemento=int(input('Digite elemento:'))
vector.append(elemento)
print(vector)
for conta_i in range(0,tamanio):
temporal=vector[conta_i]
indice_k=conta_i
for conta_j in range(conta_i+1, tamanio):
if vector[conta_j]<temporal:
temporal=vector[conta_j]
indice_k=conta_j
vector[indice_k]=vector[conta_i]
vector[conta_i]=temporal
print(vector)

22. En un arreglo es importante tomar
en cuenta que, al inicio del
ordenamiento, la parte izquierda
ordenada no tenga ningún
elemento, así que lo que se hace es
ir formando la parte ordenada con
los primeros elementos del arreglo.
Insertion Sort

23. Comparamos los dos primeros elementos (15 y 33) y, como se puede observar,
ya están ordenados de menor a mayor. Hasta aquí, nuestra lista ordenada está
compuesta sólo por el primer elemento (15).
Insertion Sort
Comparamos 33 y 27, y vemos que no están ordenados, entonces, hacemos el
intercambio. Después se compara el 27 con el 15, es decir, con la parte ordenada y vemos
que no es necesario hacer nada, así se vuelve parte de la lista ordenada.
Comparamos 33 y 10, se intercambian y después comparamos el 10 con nuestra lista
ordenada, para que pueda formar parte de ella.

24. A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] j v
15 33 27 10 35 19 42 44
Conta_i Conta_j Indice_k Intervalo Tamanio
Algoritmo InsertionSort
Escribir 'Programa Ordenamiento Insertion Sort’
Escribir 'Digite tamaño del vector’
Leer tamanio
Dimension vector[tamanio]
Para conta_i←1 Hasta tamanio Con Paso 1 Hacer
Escribir 'Digite los elementos:’
Leer elemento vector[conta_i]=elemento
Fin Para
Para conta_i←2 Hasta tamanio Con Paso 1 Hacer
temporal←vector[conta_i]
conta_j=conta_i-1
Mientras temporal<vector[conta_j] Y conta_j≥1 Hacer
vector[conta_j+1]←vector[conta_j]
conta_j←conta_j-1
Fin Mientras
vector[conta_j]←temporal
Fin Para
Para conta_i←1 Hasta tamanio Con Paso 1 Hacer
Escribir vector[conta_i]
Fin Para
FinAlgoritmo

25. print('Programa Ordenamiento Insercion Sort')
tamanio=int(input('Digite tamaño del vector:'))
vector=[]
#[15,33,27,10,35,19,42,44]
for conta_i in range(0,tamanio):
elemento=int(input('Digite elemento:'))
vector.append(elemento)
print(vector)
for conta_i in range(1,tamanio):
temporal=vector[conta_i]
conta_j=conta_i
while temporal<vector[conta_j-1] and conta_j>0:
vector[conta_j]=vector[conta_j-1]
conta_j=conta_j-1
vector[conta_j]=temporal
print(vector)

26. El método de ordenamiento Shell consiste
en dividir el arreglo (o la lista de
elementos) en intervalos (o bloques) de
varios elementos para organizarlos
después por medio del ordenamiento de
inserción directa. El proceso se repite, pero
con intervalos cada vez más pequeños, de
tal manera que al final, el ordenamiento se
haga en un intervalo de una sola posición,
similar al ordenamiento por inserción
directa, la diferencia entre ambos es qué, al
final, en el método Shell. Su nombre
proviene de su creador, Donald Shell.
Shell Sort

27. Shell Sort
Existen varias formas de calcular el
intervalo, lo cual puede mejorar la
efectividad del algoritmo. A continuación,
explicaremos la secuencia original
propuesta por Shell: n/2, n/4…, n/n, es
decir, uno (dividir entre dos, hasta que el
último intervalo sea uno), donde n es el
tamaño del arreglo. Se realiza la
ordenación, primero tomando como valor
inicial de intervalo 4; es decir, como el
número de elementos n es 8, tenemos
que n/2 = 4.
Podemos decir también que en esta
primera interacción dividimos el arreglo
en cuatro subarreglos: {15,35}, {33,19},
{27,42} y {10,44}.

28. A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] j v
15 33 27 10 35 19 42 44
Conta_i Conta_j Indice_k Intervalo Tamanio
Algoritmo shellsort
Escribir 'Programa Ordenamiento Shell Sort’
Escribir 'Digite tamaño del vector’
Leer tamanio
Dimension unaLista[tamanio]
Definir conta_i,conta_j, conta_k, temporal Como Entero
Para conta_i←1 Hasta tamanio Con Paso 1 Hacer
Escribir 'Digite elemento del vector:’
Leer elemento unalista[conta_i]=elemento
Fin Para
intervalo=trunc(tamanio/2)
Mientras intervalo>0 Hacer
Para conta_i←intervalo Hasta tamanio Con Paso 1 Hacer
conta_j←conta_i-intervalo
Mientras conta_j≥1 Hacer
conta_k←conta_j+intervalo
Si unalista[conta_j]≤unalista[conta_k] Entonces
conta_j←conta_j-1
SiNo temporal←unalista[conta_j]
unalista[conta_j]←unalista[conta_k]
unalista[conta_k]←temporal
Fin Si
Fin Mientras
Fin Para
intervalo←trunc(intervalo/2)
Fin Mientras
Para conta_i←1 Hasta tamanio Con Paso 1 Hacer
Escribir unalista[conta_i]
Fin Para
FinAlgoritmo

29. print("Programa Ordenamiento Shell Sort")
print("Digite tamaño del vector")
tamanio = int(input("Digite tamaño del vector"))
unalista = []
for conta_i in range(0,tamanio):
elemento = int(input("Digite elemento del vector:"))
unalista.append(elemento)
intervalo = int(tamanio/2)
print(unalista)
while intervalo>0:
for conta_i in range(intervalo,tamanio+1):
conta_j = conta_i-intervalo
while conta_j>=1:
conta_k = conta_j+intervalo
if unalista[conta_j-1]<=unalista[conta_k-1]:
conta_j = conta_j-1
else:
temporal = unalista[conta_j-1]
unalista[conta_j-1] = unalista[conta_k-1]
unalista[conta_k-1] = temporal
intervalo = int(intervalo/2)
print(unalista)

30. Aproximaciónde
solucionesy
búsquedabinaria
Módulo 3

31. ● Es un método que se basa en la
división sucesiva del espacio
ocupado por el vector en
sucesivas mitades, hasta
encontrar el elemento buscado.
● Esta búsqueda utiliza un método
de “divide y vencerás” para
localizar el valor deseado. Con
este método se examina primero
el elemento central de la lista; si
este es el elemento buscado
entonces la búsqueda ha
terminado.
BUSQUEDA BINARIA

32. encontrado=False
izquierda=0
derecha=tamanio
numeroBuscado=int(input('Digite numero a buscar:'))
while not(encontrado) and izquierda<=derecha:
medio=int((izquierda+derecha)/2)
if numeroBuscado==vector[medio]:
encontrado=True
elif numeroBuscado<vector[medio]:
derecha=medio-1
else:
izquierda=medio+1
if encontrado==True:
print('Numero encontrado en', str(medio+1))
else:
print('Numero no encontrado')

34. HORARIO G20

35. HORARIO G24

36. HORARIO G27