programación de sistemasmrodriguez/ordenbusqued2007.pdf · – ejemplos de implementación...

1

copyright [email protected]

Algoritmos de Ordenación

Programación de SistemasProgramación de Sistemas


Algoritmos de ordenación 2

Índice

• ¿Por qué es importante la ordenación?• Un par de ejemplos

– InsertionSort– QuickSort

• Para cada uno veremos:– En qué consisten, – Casos extremos– Eficiencia – Ejemplos de

implementación

2



¿Por qué es importante?

• Facilita la búsqueda• La información devuelta por un cómputo suele

hacerse de forma ordenada para facilitar su manejo. Ej: palabras de un diccionario, ficheros en un directorio, catálogo de una biblioteca, etc

• Una ordenación de datos inicial puede facilitar el rendimiento de un algoritmo. Ej: encontrar valores repetidos

• Muchos de los cómputos invocan internamente un método de ordenación y el coste del método de ordenación utilizado determina el coste global.



Problema inicial

• Partimos de una estructura de datos lineal que contiene cierto número de elementos.

• Esos elementos son ordenables siguiendo algún criterio.

• Para comprobar si un algoritmo de ordenación es correcto y calcular su eficiencia es necesario estudiar los casos más favorables y desfavorables y casos especiales como:– La estructura esté ordenada antes de empezar en orden

creciente o decreciente.– Que existan elementos repetidos– Etc.

3



InsertionSortOrdenación por inserción

• ¿En qué consiste?– Suponemos un array de elementos a[ ]– Suponemos que el primer elemento a[0] está ordenado.– Cogemos el siguiente elemento a[1] y lo guardamos en una

variable temporal tmp.– Comparamos uno por uno con los elementos previamente

ordenados para ver cual sería su sitio correcto.– Lo colocamos en su ubicación correcta y – Repetimos el proceso con el siguiente elemento suponiendo

ahora que a[1] y a[2] están ordenados y añadimos a[3]• Siempre suponemos que la matriz a[0] ...a[p-1] está ordenada • cogemos el elemento a[p] y lo ubicamos correctamente• Cogemos el elemento a[p+1]• Repetimos hasta que ya no quede ningún elemento nuevo que

añadir



InsertionSortImplementación

public static void insertionSort( int a[ ] )for( int p = 1; p < a.length; p++ ) //recorre desde p hasta fin del array

int tmp = a[ p ]; int j; for(j = p ; j > 0 && tmp < ( a[ j - 1 ] ); j-- )//recorre desde p hasta principio del array

a[ j ] = a[ j - 1 ]; //desplazo hacia la dcha los elementos del vector mayores que tmp

a[ j ] = tmp; //inserto tmp en la posición en la que se para j (cuando dejo de desplazar elementos)

4



InsertionSortCasos Extremos

• Cuando el array de entrada está ordenado en orden inverso – Este sería el caso peor– El bucle interno se ejecuta p+1 veces por cada valor de P: ΣP=1 (p-1)=1+2+3+4+...N

– por tanto tejecución sería Θ(N2)• Cuando el array de entrada está ordenado

– Este sería el caso mejor– El bucle interno falla siempre y el tejecución sería O(N)

• Estudiando el caso medio llegaríamos a que tejecución es Θ(N2)

• En problemas de ordenación el tejecución depende no sólo del tamaño de los datos sino también de su orden específico

N-1

8

¿Cómo medir grado de desorden?Inversiones

• El número de inversiones es una medida del grado de desorden

• Un vector ordenado no contiene ninguna inversión• Intercambiar 2 elementos desordenados elimina exactamente

una inversión• Ordenación: Si inicialmente tenemos I inversiones

– Tenemos que hacer I intercambios– El resto del trabajo es de orden N– El nº medio de inversiones de un

array de N elementos es N(N-1)/4

Llamamos Inversión a cada pareja de elementos que no están ordenados entre sí.

tejecución sería O(I+N)

tejecución sería Ω(N2)

Ejemplo:8, 5, 9, 2, 6, 3 contiene 10 inversiones(8,5), (8,2), (8,6), (8,3), (5,2), (5,3), (9,2), (9,6), (9,3) y (6,3)

5



Algoritmos de ordenaciónComplejidad

• Los algortimos de ordenación funcionan eliminando inversiones

• Todo algoritmo de ordenación que ordene por intercambios de elementos adyacentes requiere en promedio tejecución Ω(N2) por ejemplo:– InsertionSort– SelectionSort– BubleSort

• Para conseguir que se ejecute más eficientemente que tejecución Ω(N2) debe eliminar más de una inversión por intercambio



Ordenación rápida (Quicksort)

• Sea T[1..n] una matriz de n elementos.• Queremos ordenar estos elementos por

orden ascendente.• Pasos:

– Seleccionar un pivote.– Poner todos los elementos mayores que el

pivote a su derecha, y los menores a su izquierda.

– Aplicar recursivamente lo anterior a cada mitad de la matriz.

6



Ordenación rápida (Quicksort)(II)

• Nos gustaría usar la mediana como pivote.

• Encontrar la mediana requiere un tiempo excesivo.

• Elegimos como pivote un elemento arbitrario.

• Queremos descomponer T[i..j] empleando como pivote p = T[i]



Ordenación rápida (Quicksort)(III)

• Inicializamos 2 punteros: k = i, L = j + 1• Se incrementa k hasta que T[k] > p, y

se decrementa L hasta que T[L] <= p• Se intercambian T[k] y T[L]• Se continúa mientras k > L• Finalmente se intercambian T[i] y T[L]

para poner el pivote en posición correcta.

7



Ordenación rápida (Quicksort)(IV)

algoritmo pivote(T[i..j]); var L)Permuta los elementos de la matriz T[i..j] y proporciona un valor L tal que, al final, i <= L <= j; T[k] <= p para todo i <= k < L, T[L] = p, y T[k] > p para todo L < k <= j, en donde p es el valor iniciar de T[i]p T[i]k i; L j + 1repetir k k + 1 hasta que T[k] < p o k >= jrepetir L L – 1 hasta que T[L] <= pmientras k < L hacer

intercambiar T[k] y T[L]repetir k k + 1 hasta que T[k] > prepetir L L – 1 hasta que T[L] <= p

intercambiar T[i] y T[L]



Ordenación rápida (Quicksort)(V)

• Algoritmo de ordenación:algoritmo quicksort(T[i..j])

Ordena la submatriz T[i..j] por orden no decrecientesi j – i es suficientemente pequeño entoncesinsertar (T[i..j])sino

pivote(T[i..j], L)quicksort(T[i..L – 1])quicksort(T[L + 1..J])

• Para ordenar la matriz completa, basta con llamar a quicksort(T[1..n])

8



Ordenación rápida (Quicksort)(VI)

• Ejemplo. Matriz a ordenar:

• p = 3

• Se busca el primer elemento mayor que el pivote y el último elemento no mayor que el pivote:

9853562951413

9853562951413

9853562951413



Ordenación rápida (Quicksort)(VII)

• Se intercambian esos elementos:

• Se vuelve a explorar en ambas direcciones:

• Se intercambian

9854562951313

9854562951313

9854565921313

9



Ordenación rápida (Quicksort)(VIII)

• Se explora:

• Los punteros se han cruzado: se coloca el pivote.

• Se ordenan recursivamente las submatrices:

9854565921313

9854565931312

9986555433211



Ordenación rápida (Quicksort)(X)

• En término medio los subcasos no estarán demasiado desequilibrados.

• En ese caso, t(n) es O(n log n)

10



Conclusiones

• InsertionSort Ω(N2) es apropiado para pequeñas cantidades de datos

• QuickSort O(NlogN) tiene el mejor rendimiento pero es complicado de implementar es apropiado para cantidades grandes de datos.


Algoritmos de Búsqueda

Programación de SistemasProgramación de Sistemas

11



Índice

• ¿Por qué es importante la búsqueda?• Algunos ejemplos

– Búsqueda lineal– Búsqueda Binaria

• Para todos ellos veremos:– En qué consisten, – Casos extremos– Eficiencia – Ejemplos de implementación



¿Por qué es importante?

• Uno de los usos más frecuentes de los ordenadores es la búsqueda de información en estructuras de datos

• La eficiencia de un algoritmo de búsqueda depende de si el array sobre el que hacemos la búsqueda está o no ordenado. Ej: palabras de un diccionario, ficheros en un directorio, catálogo de una biblioteca, etc

• Muchos algoritmos de búsqueda invocan internamente un método de ordenación y el coste del método de ordenación utilizado determina el coste global.

Llamamos Búsqueda estática a la búsqueda que se hace sobre un array de elementos estáticos (que no modifican su valor en el t).

12



Problema inicial

• Dados:– Una estructura de datos lineal que contiene cierto

número de elementos array a[ ].– Un valor x del mismo tipo que los elementos

almacenados en el array • El algoritmo debe devolver

– La posición del elemento x en el array a[ ] o– una indicación de que no existe– Si x aparece más de una vez devuelve cualquiera

de las posiciones en la que esté almacenado.



LinearSearchBúsqueda Lineal

• ¿En qué consiste?– Partimos de:

• Un array de elementos a[ ] y • Un elemento x

– Recorremos el array de izda a dcha comparando cada uno de sus elementos con x

• Si son iguales devolvemos la posición del elemento y termina la búsqueda

• Si son distintos seguimos buscando hasta llegar al final del array y si no lo encontramos lo notificamos con un mensaje o una excepción

13



Búsqueda LinealImplementación

public static int LinearSearch(int a[], int x) int resultado = -1;for (int i = 0; i < a.length ; i++)

if (a[i] == x) return resultado=i;

elseresultado=-1;

return resultado;



Búsqueda Lineal Casos Extremos. Complejidad

• Búsqueda sin éxito– tejecución O(N) (Hay que recorrer todo el array)

• Búsqueda con éxito – Caso peor

• tejecución O(N) (Hay que recorrer todo el array)

– Caso medio• tejecución O(N) (Sólo recorremos la mitad del array)

14



Búsqueda binaria

• Como buscar una palabra en un diccionario o un nombre en la guía telefónica.

• Es una reducción.• Sea T[1..n] un array ordenado por

orden no decreciente.• Problema: encontrar un elemento x en

la matriz, si es que está.



Búsqueda binaria (II)

• Solución obvia: examinar secuencialmente todos los elementos de T, hasta llegar al final de la matriz o hasta encontrar un elemento que no sea menor que x:Algoritmo secuencial(T[1..n], x)

Búsqueda secuencial de x en una matrizpara i 1 hasta n hacer

si T[i] >= x entonces devolver idevolver n + 1

15



Búsqueda binaria (III)

• Este algoritmo es O(r), siendo r el índice que se devuelve. (O(1) en el caso mejor y O(n) en el caso peor).

• Quedándome con el caso peor: O(n)• Para acelerar la búsqueda: buscar x

sólo en una de las dos mitades de T.• Para saber con qué mitad quedarnos,

comparamos x con un elemento de la matriz.



Búsqueda binaria (IV)

• Sea k = n / 2• Si x <= T[k], buscamos en T[1..k]• Si x > T[k], buscamos en T[k+1..n]• Antes de comenzar a buscar, conviene

comprobar que x <= T[n]• El algoritmo quedaría:

16



Búsqueda binaria (V)

3126121298830-2-51 2 3 4 5 6 7 8 9 10 11

x <= T[k]?

i k j noi k j síi k j síik j no

ij i = j : alto

Búsqueda de x = 12



Búsqueda binaria (VI)

• En seudocódigo:algoritmo busquedabin(T[1..n], x)

si n = 0 o x > T[n] entonces devolver n + 1si no devolver binrec(T[1..n], x)

algoritmo binrec(T[i..j], x)Búsqueda binaria de x en la submatriz T[i..j]con la seguridad de que T[i –1] < x <= T[j]si i = j entonces devolver ik (i + j) / 2si x <= T[k] entonces devolver binrec(T[i..k], x)si no devolver binrec(T[k + 1..j], x)

17



Búsqueda binaria (VII)

• Sea t(m) el tiempo requerido por una llamada a binrec(T[i..j], x), donde m = j – i + 1

• Obviamente, el tiempo requerido por una llamada a busquedabin(T[1..n], x) es t(n), salvo por una pequeña constante aditiva.

• t(m) = t(m/2) + g(m), m > 1 y par, y g(m) es O(1)

• Utilizando el análisis general con L = 1, b = 2 y k = 0

t(m) es O(log m)



Búsqueda binaria (VIII)

• Versión iterativa:algoritmo biniter(T[1..n], x)

búsqueda binaria iterativa de x en la matriz Tsi x > T[n] entonces devolver n + 1i 1; j nmientras i < j hacerT[i – 1] < x <= T[j]k (i + j) / 2si x >= T[k] entonces j k

sino i k + 1devolver i

18



Conclusiones

• Para valores pequeños de N (ej N<6)– puede no merecer la pena la búsqueda binaria

porque utiliza aproximadamente mismo número de comparaciones que una búsqueda secuencial normal

• Las últimas iteraciones de una búsqueda binaria progresan lentamente

• Puede interesar solución híbrida– Aplicamos búsqueda binaria que termina cuando

el rango es pequeño– A partir de ese momento aplicamos búsqueda

lineal

programación de sistemasmrodriguez/ordenbusqued2007.pdf · – ejemplos de implementación...

Documents