Cap1.2 ejercicios

Programación II

Análisis de Algoritmos (II)

Ing. Mary López

Universidad Autónoma Gabriel Rene MorenoFICCT

Semestre I/2015

5. Ejercicios

Ejercicio 1: Ciclo Constante

En la complejidad Constante es O(1) . Es decir el numero de entradas no influirá en la complejidad del algoritmo.

//Complejidad constante (La repeticion es 5 veces )

void ejer1(unsigned int x)

char tmp[10];

int k=5;

for (int i=0; i < k; i++)

itoa(x,tmp,10);

MessageDlg(tmp, mtConfirmation,TMsgDlgButtons() << mbOK , 0);

x=x*2;

Ejercicio 2: Cargar un Vector

En la complejidad Lineal es O(n). Es decir el numero de entradas N indicara el limite de las iteraciones del algoritmo.

void carvec(int *vec,int n)

for (int i=0; i < n; i++)

vec[i]=1+rand()%(101-1);

N+11 N

1 N

+ +

*

T(n) = 3N+2 O(N)

Ejercicio 3: Invertir un vector (I)

En la complejidad Lineal es O(n). Es decir el numero de entradas N indicara el limite de las iteraciones del algoritmo.

void mosinv(int *vec,unsigned int n)

for (int i=n-1;i>=0;i--)

char tmp[10];

int x=vec[i];

itoa(x,tmp,10);

MessageDlg(tmp,

mtConfirmation,

TMsgDlgButtons() << mbOK , 0);

N+11 N

3 N

+ +

*

T(n) = 5N+2 O(N)

Ejercicio 4: Invertir un vector (II)

En la complejidad Lineal es O(n). ¿Podemos de alguna forma disminuir el total de instrucciones ?

void invecI(int *vec,unsigned int n)

unsigned int ini=(n/2)-1;

unsigned int fin=ini+1;

int aux;

if(n %2 != 0) fin=fin+1;

for (int i=ini; i >=0; i--)

aux=vec[i] ;

vec[i]=vec[fin];

vec[fin]=aux;

fin=fin+1;

(N/2)+11 N/2

4 N/2

+ +

*

T(n) = 3N + 5 O(N)

3

- Mejora el T(n)- Complejidad sigue LINEAL

Ejercicio 5: Invertir un vector (III)

En la complejidad Lineal es O(n). ¿Podemos de alguna forma disminuir el total de instrucciones ?

void invecII(int *vec,unsigned int n)

unsigned int med=n/2;

unsigned int fin=n-1;

int aux;

for (unsigned int i=0; i <med; i++)

aux=vec[i] ;

vec[i]=vec[fin];

vec[fin]=aux;

fin=fin-1;

(N/2)+11 N/2

4 N/2

+ +

*

T(n) = 3N + 4 O(N)

2

- Mejora el T(n)- Complejidad sigue LINEAL

Ejercicio 6Búsqueda Binaria

En la complejidad Lineal es O(n). Es decir el numero de entradas N indicara el limite de las iteraciones del algoritmo. Observe que este algoritmo divide a la mitad al conjunto por cada iteración

O (Log 2 N)

bool busBin(int *vec,unsigned int n, unsigned int clave) int menor=0; int mayor=n; bool encontrado=false; int medio; while(menor <= mayor && encontrado == False) medio = (menor + mayor) / 2; if(clave > vec[medio])

menor = medio + 1; else

if(clave<vec[medio]) mayor=medio-1;

else encontrado=true; return encontrado;

AlgoritmosDe

Ordenación

Algoritmos de Ordenación

La ordenación de elementos según un orden ascendente o descendente influye en la velocidad y simplicidad de los algoritmos que los manipulan.

En general, un conjunto de elementos se almacenan en forma ordenada con el fin de simplificar la recuperación de información manualmente, o facilitar el acceso mecanizado a los datos de una manera más eficiente.

La complejidad de cualquier algoritmo estima el tiempo de ejecución como una función del número de elementos a ser ordenados.

Cada algoritmo estará compuesto de las siguientes operaciones:

COMPARACIONES que prueban si A i< A j ó A i < B

(donde B es una variable auxiliar)

INTERCAMBIOS: permutar los contenidos de A i y A j ó A i y B

ASIGNACIONES de la forma B A i, A j B A j Ai

Generalmente, la función de complejidad solo computa

COMPARACIONES porque el número de las otras operaciones

es como mucho una constante del número de comparaciones.

Algoritmos de ordenación

Se basa en el principio de comparar e intercambiar pares de elementos contiguos hasta que todos estén ordenados.

Desde el primer elemento hasta el penúltimo no ordenado comparar cada elemento con su sucesor intercambiar si no están en orden

Ejercicio 7: Orden X Burbuja

void burbuja(int *vec,unsigned int n) int aux; unsigned int pasada; unsigned int j; for(pasada=0; pasada < n-1; pasada++)

for (j=0; j < (n-pasada-1); j++)

if (vec[j] > vec[j+1])

aux=vec[j];

vec[j]=vec[j+1];

vec[j+1]=aux;

Si en la primera PASADA se ordenara todo igual tendría que hacer las N pasadas.

N1 N-1

4 [(3+N)/2]*(n)

+ +

*

T(n) = 3N2 + 10N -1

O(N2)

[(1+N)/2]*(n)1*(N-1) [(2+N+1)/2]*(n)+ +

Detalle de la formula de la Serie

pasada N J Inc J Com J0 4 0 3 4

123

1 0 2 312

2 0 1 21

36 9

Incrementos De J --> Suma total de la serie = 1 + 2 + 3 = 6 --> [(1+N)/2]*(n)Comparaciones De J --> Suma total de la serie = 2 + 3 + 4 = 9 --> [(2+N+1)/2]*n

public void BurbujaMejor() Booleann Ordenado= false; Int pasada = 0; While ((Ordenado==false) && (pasada < N-1))

Ordenado= true; for (int j=0; j < (N-pasada-1); j++)

if (A[j] > A[j+1]) intercambiar(j,j+1); Ordenado= false;

pasada ++;

Ordenación por BurbujaMEJORADA

Realizar la tabla para 3 elementos: Numero de pasadas vs Numero de

intercambios y comparaciones

El tiempo de ejecución de dicho algoritmo viene determinado por el número de comparaciones, en el

peor de los casos O(n2).

• COMPARACIONES:

(n-1) + (n-2) + …+ 3 + 2 + 1 = n(n-1)/2 O(n2)

• INTERCAMBIOS:

(n-1) + (n-2) + …+ 3 + 2 + 1 = n(n-1)/2 O(n2)

Ordenación por BurbujaMEJORADA

Su principal ventaja es la simplicidad del algoritmo.

El problema de este algoritmo es que solo compara los elementos contiguos del VECTOR.

Si el algoritmo comparase primero elementos separados por un amplio intervalo y después se concentra progresivamente en intervalos más pequeños, el proceso sería más eficaz. Esto llevo al desarrollo de ordenación Shell y QuickSort.

Ventas Vs DesventajasOrd. Burbuja

Ejercicio 8: MergeSort

Prerrequisito :

Comprender la Recursión

El MERGESORT consiste en : Dividir los elementos en dos secuencias de la

misma longitud aproximadamente. Ordenar de forma independiente cada sub-

secuencia. Mezclar las dos secuencias ordenadas para

producir la secuencia final ordenada.

Algoritmo de fácil división y difícil unión

Arbol Merge-Sort Una ejecución de merge-sort esta representado por un

árbol binario : La raíz es la primera llamada Cada nodo representa una llamada recursiva de merge-sort

• Secuencia sin ordenar antes de la ejecución y su partición• Secuencia ordenada al final de la ejecución

Las hojas son llamadas a secuencias de tamaño 0 o 1

6 2 9 4 3 8 6 1

Ejemplo de la Ejecución

Particion del conjunto en 2 partes

7 2 9 4 2 4 7 9 3 8 6 1 1 3 8 6

7 2 2 7 9 4 4 9 3 8 3 8 6 1 1 6

7 7 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

Llamada recursiva , Particion

6 2 9 4 2 4 7 9 3 8 6 1 1 3 8 6

7 2 2 7 9 4 4 9 3 8 3 8 6 1 1 6

7 7 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

Ejemplo de la Ejecucion

mergeSort

6 2 9 4 2 4 7 9 3 8 6 1 1 3 8 6

6 2 2 7 9 4 4 9 3 8 3 8 6 1 1 6

7 7 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

Llamada recursiva , Particion


mergeSort

6 2 9 4 2 4 7 9 3 8 6 1 1 3 8 6

6 2 2 7 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

Llamada recursiva , Caso Base


mergeSort

6 2 9 4 2 4 7 9 3 8 6 1 1 3 8 6

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

Mezcla Merge


merge

6 2 9 4 2 4 7 9 3 8 6 1 1 3 8 6

6 2 2 6 9 4 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

Mezcla Merge


mergeSort

6 2 9 4 2 4 7 9 3 8 6 1 1 3 8 6

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

9 9 4 4

Llamada recursiva ,… , Caso Base, Mezcla


merge


Mezcla

6 2 9 4 2 4 6 9

6 2 2 6 9 4 4 9 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

merge


Mezcla

6 2 9 4 2 4 6 9 3 8 6 1

6 2 2 6 9 4 4 9 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

mergeSort


Mezcla

6 2 9 4 2 4 6 9 3 8 6 1

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

mergeSort


Mezcla

6 2 9 4 2 4 6 9 3 8 6 1

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

mergeSort


Mezcla

6 2 9 4 2 4 6 9 3 8 6 1

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

merge


Mezcla

6 2 9 4 2 4 6 9 3 8 6 1

6 2 2 6 9 4 4 9 3 8 3 8 6 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

mergeSort


Mezcla

6 2 9 4 2 4 6 9 3 8 6 1

6 2 2 6 9 4 4 9 3 8 3 8 6 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

mergeSort


Mezcla

6 2 9 4 2 4 6 9 3 8 6 1

6 2 2 6 9 4 4 9 3 8 3 8 6 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

mergeSort


Llamada recursiva ,… , Mezcla, Mezcla

6 2 9 4 2 4 6 9 3 8 6 1 |

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

merge


Llamada recursiva ,… , Mezcla, Mezcla

6 2 9 4 2 4 6 9 3 8 6 1 1 3 6 8

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

merge

6 2 9 4 2 4 6 9 3 8 6 1 1 3 6 8

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 6 8 9


Mezcla

merge


void mergeSort (int *A, unsigned int bajo, unsigned int

alto,unsigned int n)

if (bajo < alto) //Si hay más de un elemento

int medio = (alto + bajo)/2;

mergeSort (A, bajo, medio,n);

mergeSort (A, medio+1, alto,n);

//Proceso que mezcla el resultado de las dos llamadas anteriores

merge (A, bajo, medio+1, alto,n);


void merge (int *A, unsigned int bajo, unsigned int bajo_2,

unsigned int alto,unsigned int n)

unsigned int i = bajo; //Variable de 1ro elemento de la 1ra subsecuencia

unsigned int finbajo = bajo_2 -1; // Ultimo elemento de la 1ra subsecuencia

unsigned int j = bajo_2; //1ro elemento de la 2da subsecuencia

unsigned int k = bajo;

int *Temp=new int[n]; /* Temp es un array ya definido*/

while (( i <= finbajo) && (j<= alto))

if (A[i] <= A[j]) Temp[k++] = A[i++];

else Temp[k++] = A[j++];


while (i <= finbajo) //Si se agotan todos los elementos de la 2da subsec

Temp[k++] = A[i++];

while (j <= alto) //Si se agotaron los de la 1ra subsecuecia

Temp[k++] = A[j++];

//Paso todos los elementos del Temp al array A

for (i = bajo; i <= alto; i++)

A[i] = Temp[i];

MergeSort – Complejidad O

Si analizamos el proceso Merge: La entrada consiste en el total de elementos n y que

cada comparación asigna un elemento al vector Temp.

El número de comparaciones es (n+1) y el número de

asignaciones es n. Por lo tanto, el algoritmo de mezcla se

ejecuta en un tiempo lineal O(n). Si analizamos el proceso MergeSort :

El análisis de eficiencia de la ordenación por mezcla da lugar a una ecuación recurrente (algoritmo recursivo) para el tiempo de ejecución.

MergeSort - Complejidad

Suponemos n potencia de 2

n = 2K

log2 n = K

Tiempo de Ordenación Para N = 1, Tiempo constante. Para N > 1, El tiempo de ordenación para n números

es igual al tiempo para:• 2 ordenaciones recursivas de tamaño n/2 • El tiempo para mezclar (que es lineal)

Por tanto,

T(n) = 2 T(n/2) + n

1

1

)()2/()2/(

)1()(

nif

nif

nnTnTnT

Costo O Merge-Sort

¿Cómo se resuelve esta recurrencia?

)(*)2/(*2

)(*3)2/(*2

)(*2)4/(*4)2/(*2

)(*2)2/(*2)2/(*2

)()()2/()2/(*2*2

)()2/(*2)2/(*2

)()2/()4/(*2*2

)()2/(*2)(

33

33

2233

232

22

nknT

nnT

nnnT

nnnT

nnnnT

nnnT

nnnT

nnTnT

kk

Costo Merge-Sort

nk

n

nk

k

2log

2

12/

)log(

)(log

)log1(

log

*log1*

)(*log)1(*)(

2

2

2

2

2

2

nn

nn

nn

nnn

nnn

nnnnT

Costo Merge-Sort

La descomposición termina cuando:

Merge- Sort

En su caso mejor es Ω(n ln n)En su caso peor es O(n ln n)En su caso promedio es Ɵ (n ln n)

Por que ?

Ejercicio 9QuickSort

En la ordenación rápida, la secuencia inicial de elementos se divide en dos sub-secuencias de diferente tamaño.

La obtención de las dos sub-secuenciases el proceso que acarrea más tiempo mientras que la combinación de las sub-secuencias ordenadas para obtener la secuencia final consume muy poco tiempo.

Para dividir en dos la secuencia de elementos, se selecciona un elemento sobre el cual efectuar la división, el PIVOTE.

Se dividen los elementos en dos grupos, los elementos menores que el pivote y aquellos mayores o igual al pivote.

Algoritmo de difícil división y fácil unión,

QuickSort

La elección del elemento Pivote se puede seleccionar de diferentes formas: El mayor de los dos primeros elementos distintos encontrados. Otros criterios (1ro, Ultimo, el del centro, etc).

Para ordenar los elementos comprendidos entre Ai y Aj

1. Si desde Ai hasta Aj hay al menos dos elementos distintos

entonces comenzar la aplicación del algoritmo.

2. Seleccionar el PIVOTE como el elemento mayor de los dos primeros elementos distintos encontrados.

3. Insertar PIVOTE en la última posición.

QuickSort

4. Permutar los elementos desde Ai hasta Aj de modo que, para

algún i <= k <= j :

Ai, ..., Ak-1< PIVOTE

Ak, ..., Aj>= PIVOTE

Es decir, en las (k-1) primeras posiciones queden los elementos menores que pivote, mientras que en la posición k hacia delante queden los elementos mayores o iguales que el pivote.

5. Invocar a:

QUICKSORT desde i hasta (k –1)

QUICKSORT desde k hasta j

QuickSort - Explicacion

53

1) Elegir Pivote: Tomar un elemento

2) Dividir: Reordenar los elementos tal que x va a su

posición final E

3) Recursión y Vencer: Ordenar recursivamente

Arbol Quicksort

Inicia

Arbol Quicksort

particion

Arbol Quicksort

quickSort (I)

Arbol Quicksort

particion

Arbol Quicksort

quickSort (I)

Arbol Quicksort

particion

Arbol Quicksort

Arbol Quicksort

quickSort (D)

Arbol Quicksort

particion

Arbol Quicksort

Arbol Quicksort

quickSort (D)

Arbol Quicksort

particion

... Arbol Quicksort (final)

Ejercicio 9: QuickSort

void quickSort( int *A, int ini, int fin )

if (ini < fin)

int indicepivote = particion(A,ini, fin);quickSort(A, ini, indicepivote – 1 );quickSort(A, indicepivote+1, fin);


int particion(int *A,int ini, int fin)int pivote = A[fin];int indicepivote = ini;for ( int i=indicepivote; i< fin ; i++) if (A[i] < pivote)

intercambiar(A, i ,indicepivote);indicepivote=indicepivote+1;

intercambiar(A, indicepivote,fin); return indicepivote;


void intercambiar( int *A, int ptr1, int ptr2 ) int temp; temp = A[ptr1]; A[ptr1] = A[ptr2]; A[ptr2] = temp;

QuickSort - Complejidad

Caso Mejor: Cuando el pivote, divide al conjunto en dos subconjuntos de igual tamaño. En este caso hay dos llamadas con un tamaño de la mitad de los elementos, y una sobrecarga adicional lineal. Esto es similar al MergeSort, Luego en consecuencia el tiempo de ejecución es :

O(n log n).


Caso Peor: Se podría esperar que los subconjuntos de tamaño muy distinto proporcionen resultados malos. Supóngase que en cada paso de recursión sólo hay un

elemento menor a pivote. En tal caso el subconjunto I (elementos menores que pivote) será uno y el

subconjunto D (elementos mayores o igual a pivote) serán todos los elementos menos uno. El tiempo de

ordenar 1 elemento es sólo 1 unidad, pero cuando n > 1 ¿Qué pasa?


T(x) = T(x-1) + xSi x=N => T(N) = T(N-1) + NSi x=N => T(N-1) = T(N-2) + (N-1)Si x=N => T(N-2) = T(N-3) + (N-2)

Luego podemos ir reemplazando en :

T(N) = T(N-1) + N = T(N-2) + (N-1) + N = T(N-3) + (N-2) + (N-1) + NSi: N-3 =K = T(N-K) + (N-K+1) + (N-K+2) + (N-K+3)Si N-K=1 = T(1) + (2) + (3) +(4) = 1 + 2 + 3 + 4 + N T(N) = N (N+1) /2

O(n2).

Ejercicio 10: Complej. Cuadrática

Tablas de multiplicar hasta el 10

void ejer10() AnsiString Cadena; for (int M = 1; M <= 10; M++) for (int N = 1; N <= 10; N++) Cadena += AnsiString(M) + "x" + AnsiString(N) + "=" + AnsiString(M*N) + " "; Cadena += "\n"; ShowMessage(Cadena);

Ejercicio 11: Complej. Cubica

Obtener el Producto de 2 Matrices

void proMat(int **a, int **b, int **c, unsigned int n,unsigned int m,unsigned int p) unsigned int i,j,k; for (i=0; i<n; i++) for (j=0; j<m; j++)

c[i][j] = 0; for (k=0; k<p; k++) c[i][j] = c[i][j] + ( a[i][k] * b[k][j] );

Ejercicio 12: Complej. Exponencial

Obtener el Enésimo termino de la serie de Fibonacci 2N

unsigned int fib(unsigned int n)if(n<=1) return n;else return fib(n-1) + fib(n-2);


El análisis muestraF0=0F1=1Fn=fn-1 + fn-2 .. for n>=2

Calculando los primeros :F2=f1+f0=1+0=1F3=f2+f1=1+1=2F4=f3+f2=2+1=3F5=f4+f3=3+2=5, etc.

La siguiente figura muestra el porque es ineficiente ? Para calcular Fib(5) 15 NODOS?

El hijo de un nodo en el arbol contiene las llamadas recursivas realizadas por la llamada al NODO


N Numero de veces que computa

0 1

1 1

2 3

3 5

4 9

5 15

6 25 =2*2*2*2

Como el árbol muestra La función es ineficiente porque los valores son computados una y otra vez .

• Así por ejemplo Fib(2) es computado tres ves. (Ver Tabla) Luego que tan ineficiente es el algoritmo ?

• La figura anterior lo muestra Para fib(n) el algoritmo computa

• FOR 0<=n<=6

Ejercicio 13: Lineal Vs Exponencial

Obtener el Enésimo termino de la serie de Fibonacci O(n)

unsigned int fibI(unsigned int n) unsigned int *f=new unsigned int[n+1] ; f[0]=0; if(n>0) f[1]=1; for(int i=2; i<=n; i++) f[i]=f[i-1]+f[i-2]; unsigned int x=f[n]; delete f []; return x;

Ejercicio 13: Lineal Vs Exponencial

No se puede mejorar el

running time en fase de

implementación sin

cambiar el algoritmo !!

Web

http://www.lab.dit.upm.es/~lprg/material/apuntes/o/index.htmlhttp://latecladeescape.com/articulos/1515-que-es-la-complejidad-de-un-algoritmohttp://www.virtual.unal.edu.co/cursos/sedes/manizales/4060024/Lecciones/Capitulo%20II/rbasicas.htm

Texto electrónicohttp://www.lcc.uma.es/~av/Libro/CAP1.pdf

Libro Universidad de MálagaAntonio VallecilloDepto.. Lenguajes y Ciencias de la ComputaciónETSI Informática, Campus de Teatinos.

Cap1.2 ejercicios

Education

Transcript of Cap1.2 ejercicios