1. Introduccion al Analisis y Diseño de Algoritmos Logica y Analisis de Algoritmos Francisco Lambert 2010-1

15. Analisis de Casos

17. Analisis de Casos

18. Analisis de Casos

19. Analisis de Casos

20. Ejemplo: Algoritmo de ordenación por inserción void OrdenarInsercion (double v[], int N) { int i, j; double tmp; for (i=1; i<N; i++) { tmp = v[i]; for (j=i; (j>0) && (tmp<v[j-1]); j--) v[j] = v[j-1]; v[j] = tmp; } }

25. Resolucion de Recurrencias

26. Resolucion de Recurrencias

27. Resolucion de Recurrencias

28. Resolucion de Recurrencias

29. Resolucion de Recurrencias

30. Resolucion de Recurrencias

31. Resolucion de Recurrencias

32. Teorema Maestro θ(orden exacto), O (orden superior), Ω(orden inferior),(Notacion de Landau)

33. Teorema Maestro Ejercicios 1. T (n)=3T (n/2)+ n^2 2. T (n)=4T (n/2)+ n^2 3. T (n)= T (n/2)+2^n 4. T (n)=2nT (n/2)+ n^n 5. T (n)=16T (n/4)+ n 6. T (n)=2T (n/2)+ n log n 7. T (n)=2T (n/2)+ n/ logn 8. T (n)=2T (n/4)+ n^0.51 9. T (n)=0.5T (n/2)+1/n 10. T (n)=16T (n/4)+ n! 11. T (n)=√(2)*T(n/2)+log n 12. T (n)=3T (n/2)+ n 13. T (n)=3T (n/3)+ √n 14. T (n)=4T (n/2)+ cn 15. T (n)=3T (n/4)+ n log n 16. T (n)=3T (n/3)+ n/2 17. T (n)=6T (n/3)+ n^2 log n 18. T (n)=4T (n/2)+ n/ log n 19. T (n)=64T (n/8)− n^2 log n 20. T (n)=7T (n/3)+ n^2 21. T (n)=4T (n/2)+log n 22. T (n)= T (n/2)+ n(2 − cos n)

34. Teorema Maestro Ejercicios

35. Teorema Maestro Ejercicios

36. Algoritmos de Ordenamiento Dado un conjunto de n elementos (a1,a2,...,an) y una relacion de orden total entre dichos elementos (> por ejemplo) el problema de ordenar el conjunto de elementos se reduce a realizar permutaciones sobre el conjunto numerico con tal de ordenar dichos elementos en forma de que cumplan la relacion de orden total definida anteriormente. Aunque tanto el tipo y tamaño de los elementos como el dispositivo en donde se encuentran almacenados pueden influir en el método que utilicemos para ordenarlos, en este tema vamos a solucionar el caso en que los elementos son números enteros y se encuentran almacenados en un vector.

37. Algoritmos de Ordenamiento Existen muchos algoritmos de ordenamientos. MUCHOS. Algunos de los mas conocidos son Bubble sort, Insertion sort , Shell sort, Merge sort , Heapsort , Quicksort , Counting Sort , Bucket sort , Radix sort , Distribution sort , etc etc etc De momento, estudiaremos Mergesort (ordenamiento mediante Mezcla) y ShellSort (derivacion de InsertSort).

39. Ordenando por Mezcla o MergeSort algoritmo insertSort( A : lista de elementos ordenables ) para i=1 hasta longitud(A) hacer index=A[i] j=i-1 mientras j>=0 y A[j]>index hacer A[j + 1] = A[j] j = j - 1 fin mientras A[j + 1] = index fin para fin algoritmo

40. Ordenando Shell o ShellSort Tomemos un arreglo inicial con los datos [ 74, 14, 21, 44, 38, 97, 11, 78, 65, 88, 30 ] . Shell nos propone que hagamos sobre el arreglo una serie de ordenaciones basadas en la inserción directa, pero dividiendo el arreglo original en varios sub-arreglo tales que cada elemento esté separado k elementos del anterior (a esta separación a menudo se le llama sa lto o gap )... Se debe empezar con k=n/2 , siendo n el número de elementos de arreglo, y utilizando siempre la división entera.... después iremos variando k haciéndolo más pequeño mediante sucesivas divisiones por 2, hasta llegar a k=1. Pero vamos a ello... En nuestro ejemplo, n=11 (porque hay 11 elementos). Así que k=n/2=11/2=5 (division entera )

41. Ordenando Shell o ShellSort Empezamos con k=5. Así pues, vamos a dividir nuestro arreglo original en 5 sub-arreglo, en los cuales, sus elementos estarán separados por 5 lugares del arreglo original (el salto o gap es 5). Vamos a hacerlo con colores. Tomamos el primer elemento (el 74) contamos 5 lugares y tomamos también otro elemento (el 97) volvemos a contar 5 y tomamos otro (el 30) y acabamos porque se nos acaba el arreglo. El primer sub-arreglo con k=5 es el formado por 74, 97 y 30. Vamos a pintarlos en rojo [ 74 , 14, 21, 44, 38, 97 , 11, 78, 65, 88, 30 ]

42. Ordenando Shell o ShellSort Ahora, ordenaremos los elementos del sub-arreglo rojo pero sólo entre ellos, utilizando el algoritmo de Inserción directa. 30 , 14, 21, 44, 38, 74 , 11, 78, 65, 88, 97 Fíjate qué curioso. El 30, un elemento relativamente pequeño se ha ido hacia el principio y el 97 hacia el final... ¡pero dando saltos ( gap ) de 5 en 5 lugares! Cada uno ha avanzado en saltos de 5 hacia una posición cercana a su ubicación definitiva.

43. Ordenando Shell o ShellSort El 30, un elemento relativamente pequeño se ha ido hacia el principio y el 97 hacia el final... ¡pero dando saltos ( gap ) de 5 en 5 lugares! Cada uno ha avanzado en saltos de 5 hacia una posición cercana a su ubicación definitiva. Formemos ahora otro sub-arreglo con salto k=5... partiendo del segundo elemento (el 14) y contando 5 (tomamos también el 11) y ya está, porque se acaba el arreglo. 30 , 14 , 21, 44, 38, 74 , 11 , 78, 65, 88, 97

44. Ordenando Shell o ShellSort Ordenando la parte verde con InsertSort tenemos ahora 30 , 11 , 21 , 44 , 38 , 74 , 14 , 78 , 65 , 88 , 97 Ordenando de pasada la parte rosada que se mantiene igual , lo mismo ocurre con el naranjo y el celeste !. Hemos formado 5 sub-arreglos en los cuales los elementos están separados por 5 lugares (porque k=5). Hemos ordenado cada sub-arreglo por separado utilizando inserción directa, y hemos logrado que cada elemento se dirija hacia su ubicación definitiva en pasos de 5 lugares. Por supuesto, no hemos terminado todavía, pero resulta evidente que algunos elementos, como el 30, el 97 o el 11 han dado un gran salto y que no deben andar muy lejos de su sitio final.

45. Ordenando Shell o ShellSort Decimos ahora que el arreglo está 5-ordenado. Para continuar con el algoritmo, debemos ir reduciendo progresivamente k dividiéndolo sucesivamente por 2 y k-ordenando los sub-arreglos que nos salgan (recuerda que nos salen k sub-arreglo). Cuando lleguemos a k=1 habremos terminado. Pero de momento, nuestra k valía 5, así que ahora k←k/2=5/2=2 Nuestra nueva k vale 2. Repetimos todo el tinglado, pero ahora nos saldrán 2 sub-arreglo cuyos elementos están separados por 2 lugares.

46. Ordenando Shell o ShellSort Decimos ahora que el arreglo está 5-ordenado. Para continuar con el algoritmo, debemos ir reduciendo progresivamente k dividiéndolo sucesivamente por 2 y k-ordenando los sub-arreglos que nos salgan (recuerda que nos salen k sub-arreglo). Cuando lleguemos a k=1 habremos terminado. Pero de momento, nuestra k valía 5, así que ahora k←k/2=5/2=2 Nuestra nueva k vale 2. Repetimos todo el tinglado, pero ahora nos saldrán 2 sub-arreglo cuyos elementos están separados por 2 lugares.

48. Ordenando Shell o ShellSort Sin embargo, las k-ordenaciones que hemos hecho (con k=5 y k=2) han hecho que cada elemento se aproximase con saltos de 5 y luego de 2 posiciones hacia su ubicación definitiva. Ahora que k=1 y que vamos a aplicar el algoritmo de inserción directa tal cual, haremos muchas menos comparaciones e intercambios que si lo hubiéramos aplicado con en arreglo tal como lo teníamos al empezar. El algoritmo de inserción directa se comporta tanto mejor cuanto más cerca está cada elemento de su sitio definitivo. Finalmente, el arreglo queda de ésta manera: 11, 14, 21, 30, 38, 44, 65, 74, 78, 88, 97 Cada elemento descolocado ha tenido que moverse pocos lugares. Muchos de ellos ni siquiera se han movido.