Diseño y análisis de algoritmos

Presentación del tema: "Diseño y análisis de algoritmos"— Transcripción de la presentación:

1 Diseño y análisis de algoritmos

2 Temario Clasificación Arreglos Ej:inserción Ej:Selección
Ej:Intercambio Ej:Partición :QuikSort

3 Clasificación Arreglos Estructura base
TYPE index = INTEGER ; VAR d:ARRAY[1..N] of item Estos métodos se conocen como directos Se verán rápidamente porque: Permitien dilucidar los princípos de los problemas de clasificación Algoritmos cortos y fáciles de entender Lós algoritmos más eficientes son más complejos y deben usarse sólo para n Grándes

4 Clasificación Arreglos Alg1.1: Inserción directa Pseudocódigo
Para i:=2 a n { X:=d[i]: Insertar x en el sitio que corresponde en d1...di } Cond. Término: Se en encuentra un elemento aj que tiene una llave menor que la x El extremo izquierdo de la secuencia de destino se ha alcanzado Se agrega en cada ciclo un centinela por lo tanto el arreglo aumenta [0..n] Procedure insersión directa; Var i,j:index;x:item; BEGIN For i:=2 TO n DO x:=d[i];d[0]:=x;j:=i; WHILE (x<d[j-1]) DO d[j]:=d[j-1];j:=j-1 END; d[j]:=x END Análisis: Mejor Caso pert O(n) Resto pert O(n ) Es dependiente del orden Inicial de los datos?? 2

5 Clasificación Arreglos Alg1.1: Inserción directa Ejemplo:
Datos iniciales: i= i= i= i= i= i= i= El algoritmo es sensible al orden inicial, y el número de copmaraciones depende de los valores Si los elementos están ordenados no entrará nunca al mientras, por lo tanto hará un Recorrido lo que da un O(n). El peor caso se da cuando los elementos están en orden inverso al deseado Notar que de 1 hasta i se mantiene siempre un orden (relativo). Esto sugiere buscar más rápidmente el punto de inserción que un retroceso secuencial. La idea es agregar una búsquda binaria que prueba la secuencia destino en la mitad, luego reduce la busqueda a la mitad hasta encontrar el punto de inserción. El algoritmo de inserción modificado se llama inserción binaria

6 Clasificación Arreglos Alg2.1: Inserción directa, Insersión binaria
Procedure InsBin; VAR i,j,m,L,R:index;x:item; BEGIN FOR i:=2 TO n DO X:=d[i];L:=1;R:=i; WHILE L<R DO m:= (L+R)DIV2; IF d[m] <= x THEN L:= m+1 ELSE R:=m END; FOR j:=i DOWNTO R+1 DO d[j]:=d[j-1]; d[R]:=x END

7 Clasificación Arreglos Alg1.2: Inserción directa, Insersión binaria
El algoritmo es sensible al orden inicial, La posición de inserción se encuentra si L=R, por lo que el intervalo final de búsqueda debe ser de largo 1, por lo que cada vez se divide el intervalo de búusqueda en la mitad. Por lo tanto se supone dividir a la mitad el intervalo de longitud i veces por tanto: Esta suma se puede aproximar por la integral Por lo tanto el número de comparaciones pruducto de la búsqueda binaria es del orden , sin embargo aún queda el segundo for que en conjunto con el primero mantien el Algoritmo en un orden El prblema de fondo de este método de ordenamiento es que cada vez que debe reorenar desplaza un segmento completo de los datos. Veremos otras Alternativas, como el ordenamiento por selección directa.

8 Clasificación Arreglos Alg2: Selección directa Diseño
Seleccionar el elemento que tenga la llave menor. Intercambiarlo con el primer elemento d[1]. Repetir 1 y 2 con (n-1) elementos restantes, (n-2) elementos restantes FIN queda un solo elemento --- El más grande Pseudocódigo Para i:=1 a n -1 {Asignar el índice del elemento más pequeño entred1...di a k Intercambiar di con dk } Procedure selecdirecta; Var i,j,k:index;x:item; BEGIN FOR i:=1 TO n-1 DO k:=i; x=d[i]; FOR j:=i+1 TO n DO IF (d[j] <x) THEN k:=1; x :=d[j]; END; d[k]:=d[i]; d[i]:=x END Arreglo inicial:

9 Clasificación Arreglos Alg 2: Selección directa
El algoritmo es sensible al orden inicial, el número de comparaciones es independiente de los datos, al contrario que la inserción directa. Hay un segundo for fijo. Si es el número de comparaciones necesarias, se puede pensar que, dado que el segundo for se va haciendo cada vez más pequeño en una unidad: El patrón se puede reconocer dándose valores: Por otro lado en el mejor habrá que ahcer alrdedor de n asignaciones y las comparaciones se por lo que el algoritmo será del así como en el peor caso. Preferible alanterior

10 Clasificación Arreglos Alg3: intercambio directo Diseño
Todos los métodos tienen de alguna manera operaciones de intercambio. Este algoritmo es el famoso ordenamiento de burbuja Procedure burbuja; Var i,j:index;x:item; BEGIN FOR i:=2 TO n DO FOR j:=n DOWNTO i DO IF (d[j-1] > d[j]) THEN x:=d[j-1]; d[j-1]:=d[j]; d[j]:=x END Arreglo inicial: El núero de comaraciones necesarias se calcula con la misma lógica que el Algoritmo anterior por lo que el orden es A pesar de que no se Puede mejorar su orden, deteniendo el algoritmo si el orden seha comletado.

11 Clasificación Arreglos Alg 4: Partición:Quiksort
El es l más rápido para clasificar. Se basa en intercambiar y particionar. Una primera Aproximación: Seleccionar un elemento al azar del arreglo x Se recorre el arreglo a partir de la izquierda hasta encontrar un elemento i > x Se recorre el arreglo desde la derecha hasta encontrar un elemento j < x A continuación se intercambian ambos elementos y se vuelve a 2 hasta que i y j se Encuentren en algún punto cerca del centro del arreglo. El resultado es que se ha dividido el arreglo la parte a la izquierda del elemento x con elementos menores o iguales a x y la derecha con elementos mayores o iguales. Procedure particion; Var i,j:index;w,x:item; BEGIN i:=1;j:=n; (*seleccionar un elemento de d al azar y asignar a x*) REPEAT WHILE d[i] < x DO i:=i+1; WHILE d[j] > x DO j:=j-1; IF i <=j THEN w:=a[i];a[i]:=a[j];a[j]:=w;i:=i+1;j:=j-1 END UNTIL i>j; Arreglo inicial:x=42

12 Clasificación Arreglos Alg 4: Partición:Quiksort
Se debe recordar que lo que lo que se quiere es ordenar. Sin embargo Una vez que se tiene un algoritmo eficiente de partición, se tiene dividido el arrgelo, por lo que el sigueinte paso es aplicar el mismo procedimiento a la partición izquierda, luego a la derecha y así sucesivamente hasta que cada partición conste de un solo elemento. Claramente esta es una definición recursiva Criterio de parada, establecido cuando las particiones son de un elemento. Convergencia, asegurada porque las particiones siempre son cada vez más pequeñas. Procedure qsort(L,R:index); Var i,j:index;w,x:item; BEGIN i:=L;j:=R; x:= d[(L+R) DIV 2)] REPEAT WHILE d[i] < x DO i:=i+1; WHILE d[j] > x DO j:=j-1; IF i <=j THEN BEGIN w:=a[i];a[i]:=a[j];a[j]:=w;i:=i+1;j:=j-1 END UNTIL i>j; IF L< j THEN qsort(L,j); IF R> i THEN qsort(i,R); qsort(1,n); Arreglo inicial:x=42 qsort(1,3) x=6 06 fin Qsort(2,3) 18 12 12 18 fin Qsort(5,8)....

13 Clasificación Arreglos Alg3: QuikSORT Análisis:
Cómo es el comportamiento del proceso de partición?? Tras haber seleccionado un límite x, recorre todo el arreglo. De ahí se efectúan exactamente n comparaciones El número de intercambios puede determinarse con el sguiente método probabilístico: Con un límite fijo x, el número previsto de operaciones de intercambio es igual al de elementos en la parte izquierda de la partición, o sea n – 1 * Prob( elemento haya alcanzado su su lugar mediante un INTERCAMBIO). Habrá tenido lugar un intercambio si el elemento ha sido antes parte de la partición DERECHA; P(de este evento)=(n-(x-1))/n. El número esperado de intercambios es el promedio de esos valores previstos sobre todos los LIMITES posibles x.: Si se eligiera SIEMPRE la mediana como límite , cada proceso divide el arreglo en 2 mitades y el número de pases necesarios sería de log(n). El número ideal de comparaciones será de f=n*log n E intercambio, g=n*log(n)/ Pero la probabilidad de esto es apenas de 1/n. El rendimientoMedio de QS es inferior al caso óptimo por 2*ln(2). Por otro lado se puede dar un mal caso y comportarse

14 Clasificación Arreglos Alg3: QuikSORT no recursivo: Procedure qsort;
CONST M=100; Var i,j,L,R:index;w,x:item; s: 0..M; stack: ARRAY[1..M] of RECORD L,R:Index END; BEGIN s:=1; satack[1].L=1;stack[1].R=n; REPEAT (*tomar petición encima del stack*) L:= stack[s].L; R:= stack[s]. R;s:=s-1; REPEAT (*Particion*) i:=L;j:=R; x:= d[(L+R) DIV 2)]; REPEAT WHILE d[i] < x DO i:=i+1; WHILE d[j] > x DO j:=j-1; IF i <=j THEN BEGIN w:=a[i];a[i]:=a[j];a[j]:=w;i:=i+1;j:=j-1 END UNTIL i>j; IF R> i THEN (*apilar petición para ordenar paricion derecha* s:=s+1; stack[s].L=i; stack[s].R=R; R:=j; UNTIL L>=R (*ahora Ly R delelimitan particion izquierda*) UNTIL s=0 EBD qsort;