HERRERA MAYA LUIS AL11505750

Instrucciones: Resuelve los siguientes ejercicios que se presentan a continuation

a. Calcula los tiempos de ejecucion en el mejor, peor, y caso promedio del
programa siguiente:
Constante n = un numero entero (int)
Type vector = Array [1..n] de int
Programa Algoritmo1(VAR a:vector)
int i,j
int temp

BEGIN
For i=1 to n-1 do
For j=n to i+1 by -1 do
If a[j-1]>a[j] then
temp=a[j-1]
a[j-1]=a[j]
a[j]=temp
END IF
END FOR
END FOR
END Algoritmol;

Como primer paso estableceremos el numero de operaciones elementales (OPEL) que se
ejecutan en el algoritmo:

La cantidad de operaciones por cada iteration interior, en caso de que a[j-1] > a[j] esta
dada por:
T(n) = 3 + 2 + 2 + 1 + 2 = 10
Para el caso de que no se cumpla la condition a[j-1 ] > a[j]
Instruction OPEL
For i=1 to n-1 do

For j=n to i+1 by -1 do

If a[j-1]>a[j] then 3
temp=a[j-1] 2
a[j-1]=a[j] 2
a[j]=temp 1
END IF

END FOR 2
END FOR 2
1
2
8
9
T(n) = 3 + 2 = 5
Cabe hacer mencion que en todos los casos las veces que se ejecutan ambas iteraciones
es igual, lo unico que difiere es la cantidad que se ejecutan las asignaciones dentro del
bucle if, lo que hace que se ejecuten n-1 veces el ciclo interior, y n-1 veces el ciclo interior,
o un total de n
2
-2n+1 veces ambos ciclos.
En cuanto al tiempo de ejecucion se tiene que se ejecutan dos OPEL en el ciclo exterior,
lo que hace para el mejor de los casos
T(n) = 2 (n-1) * 5 (n-1) = 10n2-20n+10
Y para el peor de los casos en que se ejecutarian los ciclos if para todos los casos:
T(n) = 2 (n-1) * 10 (n-1) = 20n2-40n+20
El cual toma el doble de tiempo que del mejor de los casos, lo cual podemos deducir que
para el caso promedio tendriamos
T(n) = 15n2-15n+15
Dependiendo de la cantidad de elementos del arreglo (n)
b. Investiga acerca del algoritmo de Ordenamiento por Insercion (Insertion
Sort).
i. Escribe el procedimiento para que ordene de forma creciente.
ii. Construye su representation en pseudocodigo
iii. Construye su representacion en diagrama de flujo
iv. Programa el codigo en lenguaje C o Java, y reporta los resultados
Este metodo de ordenacion itera un elemento por cada repetition moviendolo a una
position ordenada en una lista creciente. Por cada iteration, el algoritmo remueve un
elemento de los datos de entrada, encuentra la localidad que le pertenece dentro de una
lista ordenada de elementos previamente iterados y lo inserta ahi. Se repite hasta que no
existan elementos de entrada.
Cabe hacer mention que es comun que la ordenacion se realiza en el mismo arreglo de
entrada, esto para evitar uso adicional de memoria; la ordenacion se realiza iterando el
arreglo de entrada, haciendo que la lista ordenada crezca al inicio de el. En cada posicion
del arreglo, se verifica el valor de esa posicion contra el valor mas alto de la lista ya
ordenada. Si es mayor, deja el elemento en lugar y se mueve al siguiente. Si es menor,
encuentra la posicion correcta dentro de la lista ordenada, y mueve todos los valores mas
grandes para hacer espacio para insertar el valor en la posicion correcta.
Para el pseudocodigo, por simplicidad se omite la llamada desde una rutina main,
llenado del arreglo, y mostrar el arreglo ordenado.
1. Inicio de rutina de ordenacion (parametros: variable arreglo con valores
a ordenar pasado por referencia)
2. Declara variables indice indice, indice_previo, cantidad._elementos y
valor_actual
cantidad._elementos <- cantidad de elementos en arreglo
indice <- 1
for indice < cantidad._elementos - 1
valor_actu.al = arreglo [indice]
indice_previo <- indice 1
while indice_previo >= 0 and arreglo[indice_previo] > valor_actu.al
arreglo [indice] <- arreglo [indice_previo]
indice_previo <- indice_previo 1
end-while
arreglo[indice] <- valor
end-for
3. retorna a funcion principal
4. Fin
Pseudocodigo de algoritmo de ordenamiento por insercion
Diagrama de flujo de algoritmo de ordenamiento por insercion
#include <stddef.h>
#include <stdio.h>
void ordenacion_insercion (int *arreglo,
const size_t cam.tidad_elementos)
i {
size t indice, indice previo;
int value;
for (indice = 1; indice < cantidad_eleraentos; indice++)i
i {
value = arreglo [indice];
for (indice_previo = indice; indice_previo > 0 && value < arreglo[indice_previo - 1]; indice_previo )
i i arreglo[indice previo] = arreglo[indice previo - 1];
arreglo[indice_previo] = value;
}
}
int main(void)
If
int indice, cantidad_elementos;
/* define con !& */
int arreglo[] = (4, 65, 2, -31, 0, 99, 2, 33, 732, 1};
/ * ) */
cantidad_elementos = sizeof arreglo / sizeof arreglo[0];
ordenacion_insercion (arreglo, cantidad_eleraentos) ;
for (indice = 0; indice < camtidad_elementos; indice++)
printf("%d arreglo [indice] )< ;
print f (
rr
\n
rr
) ;
return 0;
}
Implementacion en C de algoritmo de ordenamiento por insercion
Al compilar el programa y ejecutarlo nos muestra el arreglo ordenado ascendentemente:
cri sto. al am" 5@fliMmal2rd422l0B
5 ./a.exe
-31 0 1 2 2 4 65 83 99 7G2
Ejecucion de programa compilado de algoritmo de ordenamiento por insercion
c. Reescribe el procedimiento de Ordenamiento por Insercion del ejercicio
anterior para que lo ordene de forma decreciente.
i. Construye las nuevas representaciones (pseudocodigo y diagrama
de flujo).
ii. Programa el codigo para que acepte un valor de seleccion que
determine la entrega del resultado (orden creciente o decreciente
seleccionable en pantalla).
Para el pseudocodigo, por simplicidad se omite la llamada desde una rutina main,
llenado del arreglo, y mostrar el arreglo ordenado, a diferencia del paso anterior se hace
que los elementos se corran si son mayores y no menores (se subraya la diferencia del
programa previo).
5. Inicio de rutina de ordenacion (parametros: variable arreglo con valores
a ordenar pasado por referencia)
6. Declara variables indice indice, indice_previo, cantidad._elementos y
valor_actual
cantidad._elementos <- cantidad de elementos en arreglo
indice <- 1
for indice < cantidad._elementos - 1
valor_actu.al = arreglo [indice]
indice_previo <- indice 1
while indice_previo >= 0 and arreglo[indice_previo] > valor_actu.al
arreglo [indice] <- arreglo [indice_previo]
indice_previo <- indice_previo 1
end-while
arreglo[indice] <- valor
end-for
7. retorna a funcion principal
8. Fin
Pseudocodigo de algoritmo de ordenamiento por insercion en orden descendente
Diagrama de flujo de algoritmo de ordenamiento por insercion en orden descendente
# include < stddef.h>
#include <stdio.h>
void ordenacion_insercion (int *arreglo, const size_t cantidad_elementos, const int opcion)
{
size_t indice, indice_previo;
int value;
for (indice = 1; indice < cantidad_elementos; indice++)
{
value = arreglo [indice];
if (opcion = 0)
for (indice_previo = indice; indice_previo > 0 && value < arreglo[indice_previo
arreglo[indice_previo] = arreglo[indice_previo - 1];
else
for (indice_previo = indice; indice_previo > 0 && value > arreglo[indice_previo
arreglo[indice_previo] = arreglo[indice_previo - 1];
arreglo[indice_previo] = value;
}
}
int main(void)
{
int indice, cantidad_elenientos, opcion_seleccionada;
/* define con */
int arreglo[] = {4, 5, 2, -31, 0, 99, 2, 33, 732, 1};
cantidad_elementos = sizeof arreglo / sizeof arreglo[0];
printf (".SSwSfifiiSSS \n\n0. sxSSJVSS gSSS^JSSSSX^l SSaSSSJjSSiS'-.ti:
scanf {"%d
rr
, &opcion_seleccionada) ;
ordenacion_insercion (arreglo, cantidad_e1ementos, opcion_seleccionada);
for (indice = 0 ; indice < cantidad_elementos; indice++)
printf("%d ", arreglo[indice]);
printf ("\n");
return 0;
}
Implementacion en C de algoritmo de ordenamiento por insercion ascendente o
descendente
Al compilar el programa y ejecutarlo nos pregunta el orden y da el arreglo ordenado
apropiadamente:
cristo.alanis@mxnal2rd422103 ~
$ ./a.exe
Seleccione la opcion:
0. ordenar ascendente
1. ordenar descendente
: 0
-31 0 1 2 2 4 65 83 99 782
cristo. alanis@mxinal2rd422103 ~
S . f a, . exe
Seleccione la opcion:
0. ordenar ascendente
1. ordenar descendente
: 1
782 99 83 65 4 2 2 1 0 -31
Ejecucion de programa compilado de algoritmo de ordenamiento por insercion
ascendente o descendente
- 1] ; indice_previo )
- 1] ; indice_previo )
Referencia:
http://es.wikipedia.org/wiki/Ordenamiento por inserci%C3%B3n