Taller N 1 Practica Python

Jose Ivn Carpintero Nario

Implemente el algoritmo de ordenamiento por insercin en Python.

El algoritmo correspondiente a la ordenacin por insercin contempla los siguientes

pasos:
1. El primer elemento A [0] se considera ordenado; es decir, la lista inicial consta de un
elemento.
2. Se inserta A [1] en la posicin correcta, delante o detrs de A [0], dependiendo de que
sea menor o mayor.
3. Por cada bucle o iteracin i (desde i=1 hasta n-1) se explora la sublista A [i-1]. . A[0]
buscando la posicin correcta de insercin; a la vez se mueve hacia abajo (a la derecha
en la sublista) una posicin todos los elementos mayores que el elemento a insertar A[i],
para dejar vaca esa posicin.
4. Insertar el elemento a la posicin correcta
def insertionSort(alist):
for index in range(1,len(alist)):
currentvalue = alist[index]
position = index
while position>0 and alist[position-1]>currentvalue:
alist[position]=alist[position-1]
position = position-1
alist[position]=currentvalue
alist = [54,26,93,17,77,31,44,55,20]
insertionSort(alist)
print(alist)
Escriba una funcin que determine si un arreglo dado se encuentra en orden.

La insercin se ejecuta una vez en su mejor de los casos y se ejecuta en sus peores
casos y promedio.

Anlisis peor y promedio de caso:

El peor de los casos para la ordenacin por insercin se producir cuando la lista de
entrada est en orden decreciente. Para insertar el ltimo elemento, que necesitamos
en la mayora de las comparaciones y en la mayora de los swaps. Para insertar el
segundo al ltimo elemento, que necesitamos en la mayora de las comparaciones y
en la mayora de los intercambios, y as sucesivamente. El nmero de operaciones
necesarias para llevar a cabo la ordenacin por insercin, por tanto, es: Para calcular
la recurrencia relacin de este algoritmo, utilice la siguiente suma: Se deduce que uso
del teorema maestro para resolver este recurrencia para el tiempo de ejecucin. Como
era de esperar, la complejidad del algoritmo es la hora de analizar los algoritmos, el
promedio de los casos a menudo tiene la misma complejidad que el peor de los
casos. As ordenacin por insercin, en promedio, toma tiempo.

def insertion_sort(array):
for slot in range(1, len(array)):
value = array[slot]
test_slot = slot - 1
while test_slot > -1 and array[test_slot] > value:
array[test_slot + 1] = array[test_slot]
test_slot = test_slot - 1
array[test_slot + 1] = value
return array

Prubese con un arreglo de 100 enteros generados aleatoriamente con 100 enteros entre -20
y 40. Use la lnea de comando y el intrprete interactivo para verificar que si ordena
ejecutndolo varias veces.
import unittest
import random
def insertion_sort(seq):
"""Acepta una secuencia, utiliza algoritmo de ordenacin por
insercin para ordenar. Devuelve una lista ordenada"""
partition = 1
while partition < len(seq):
temp = partition
#mientras que el temp no est en posicin correcta en la
sublista, decrementa la posicion
while temp != 0 and seq[temp] < seq[temp-1]:
seq[temp], seq[temp-1] = seq[temp-1], seq[temp]
temp -= 1
partition += 1
return seq
class test_insertionsort(unittest.TestCase):
def test_insertionsort(self):
"""Test insertion_sort()"""
seq = [random.randrange(-20, 40) for _ in range(100)]
self.assertEqual(insertion_sort(seq), sorted(seq))
print(test_insertionsort())
print (seq)
if __name__ == '__main__':
unittest.main()

Prubese con arreglos de n=100,200,300,400,..,900,1000 enteros distintos entre 1 y n, en tres

casos, ordenados ascendentemente, ordenados descedentemente y ordenados
aleatoriamente (revise random.shuffle()). Para cada caso, haga 10 ejecuciones para
cada n y grafique en Excel el tiempo promedio en las 10 ejecuciones (revise time.clock()) en
funcin de n.

0rden Ascendente
0,0002500000000000
0,0002000000000000
0,0001500000000000
0,0001000000000000
0,0000500000000000
0,0000000000000000
0

200

400

600

800

1000

Orden Descendente
0,0000300000000000000
0,0000250000000000000
0,0000200000000000000
0,0000150000000000000
0,0000100000000000000
0,0000050000000000000
0,0000000000000000000
0

200

400

600

800

1000

1200

1200

Orden Aleatorio
0,1200000000000000
0,1000000000000000
0,0800000000000000
0,0600000000000000
0,0400000000000000
0,0200000000000000
0,0000000000000000
0

200

400

600

800

1000

1200