1 Ordenación, Clasificación Introducción Algoritmos Complejidad

2 Introducción Ordenación o clasificación es el proceso de reordenar un conjunto de objetos en un orden específico. El propósito de la ordenación es facilitar la búsqueda de elementos en el conjunto ordenado. Existen muchos algoritmos de ordenación, siendo la diferencia entre ellos las ventajas de unos sobre otros en la eficiencia en tiempo de ejecución.

3 Introducción En lo que sigue se considera que la estructura lineal (array, lista, vector o secuencia) a ordenar se representa por un array de objetos (números enteros): int a[ ] = new int[MAX]; siendo MAX el número máximo de elementos del array. El orden de los elementos después de la ordenación se considera ascendente.

4 Algoritmo burbuja Es un método caracterizado por la comparación e intercambio de pares de elementos hasta que todos los elementos estén ordenados. En cada iteración se coloca el elemento más pequeño (orden ascendente) en su lugar correcto, cambiándose además la posición de los demás elementos del array.

5 Algoritmo burbuja

6

7

8

9

10 Algoritmo burbuja for(i=n;i>0;i--) for(j=0;j<i-1;j++) if (a[j] > a[j+1]) { t=a[j]; a[j] = a[j+1]; a[j+1]=t; ninterc++; }

11 Algoritmo sacudida (shakesort) Es una mejora del algoritmo de burbuja en el que se registra la ocurrencia de un intercambio y el índice del último intercambio y se alterna la dirección de las pasadas consecutivas. Con ello una burbuja liviana en el lado “pesado” y una pesada en el lado “liviano” quedarán en orden en una pasada simple.

12 Algoritmo sacudida (shakesort) l=1; r=n-1; k=n-1; do { for(j=r; j>=l; j--) if (a[j-1]>a[j]) { t=a[j-1]; a[j-1] = a[j]; a[j]=t; k=j; ninterc++; } l=k+1; for(j=l; j<=r; j++) if (a[j-1]>a[j]) { t=a[j-1]; a[j-1] = a[j]; a[j]=t; k=j; ninterc++; } r=k-1; } while (l<r);

13 Algoritmo inserción Este método es usado por los jugadores de cartas. Los elementos están divididos conceptualmente en una secuencia destino y una secuencia fuente. En cada paso, comenzando con i=2 e incrementando i en uno, el elemento i-ésimo de la secuencia fuente se toma y se transfiere a la secuencia destino insertándolo en el lugar adecuado. En otras palabras, en el i-ésimo paso insertamos el i-ésimo elemento a[i] en su lugar correcto entre a[1], a[2],…., a[i-1], que fueron colocados en orden previamente.

14 Algoritmo inserción

15 Algoritmo inserción

16 Algoritmo inserción

17 Algoritmo inserción

18 Algoritmo inserción

19 Algoritmo inserción

20 Algoritmo inserción

21 Algoritmo inserción

22 Algoritmo inserción for(i=1;i<n;i++) { j=i-1; t=a[i]; while (j>=0 && t<a[j]) { a[j+1] = a[j]; j=j-1; } a[j+1]=t; }

23 Algoritmo selección En éste método, en el i-ésimo paso seleccionamos el elemento con la llave de menor valor, entre a[i],…, a[n] y lo intercambiamos con a[i]. Como resultado, después de i pasadas, el i-ésimo elemento menor ocupará a[1],…, a[i] en el lugar ordenado.

24 Algoritmo selección

25 Algoritmo selección

26 Algoritmo selección

27 Algoritmo selección

28 Algoritmo selección

29 Algoritmo selección

30 Algoritmo selección

31 Algoritmo selección

32 Algoritmo selección for(i=0;i<n-1;i++) { k=i; t=a[i]; for (j=i+1; j<n; j++) { if (a[j] < t) { t= a[j]; k=j; } a[k]= a[i]; a[i]= t; }

33 Algoritmo rápido (Quicksort) La ordenación rápida se basa en el hecho que los intercambios deben ser realizados preferentemente sobre distancias grandes. El algoritmo a seguir es el mismo que se aplica cuando se quiere ordenar un gran montón de exámenes: –Seleccionar un valor de división (L por ejemplo) y dividir el montón en dos pilas, A-L y M-Z. Después se toma la primera pila y se subdivide en dos, A-F y G-L por ejemplo. A su vez la pila A-F puede subdividirse en A-C y D-F. Este proceso continúa hasta que las pilas sean suficientemente pequeñas para ordenarlas fácilmente. El mismo proceso se aplica a la otra pila.

34 Algoritmo rápido (Quicksort) En este caso se toma un elemento x del array (el del medio por ejemplo), se busca en el array desde la izquierda hasta que >x, lo mismo se hace desde la derecha hasta encontrar <x. Después se intercambia esos elementos y se continúa ese proceso hasta que los índices se encuentren en la mitad del array. Se aplica el mismo proceso para la porción izquierda del array entre el extremo izquierdo y el índice derecho y para la porción derecha entre el extremo derecho y el último índice izquierdo.

35 Algoritmo rápido (Quicksort) Descripción del algoritmo: 1) Dividir : Si la secuencia S tiene 2 o más elementos, seleccionar un elemento x de S como pivote. Cualquier elemento arbitrario, como el último, puede servir. Elimiar los elementos de S dividiéndolos en 3 secuencias: L, contiene los elementos de S menores que x E, contiene los elementos de S iguales a x G, contiene los elementos de S mayores que x 2) Recursión: De forma recursiva ordenar L y G 3) Vencer: Finalmente, colocar nuevamente los elementos en S en orden, primero insertar los elementos de L, después E, y los elementos de G.

36 Idea de Quick Sort 1) Selección: 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

37 Arbol Quicksort

38 Arbol Quicksort

39 Arbol Quicksort

40 Arbol Quicksort

41 Arbol Quicksort

42 Arbol Quicksort

43 Arbol Quicksort

44 Arbol Quicksort

45 Arbol Quicksort

46 Arbol Quicksort

47 Arbol Quicksort

48 Arbol Quicksort

49... Arbol Quicksort (final)

50 Quicksort In-Place Paso Dividir: l recorre la secuencia desde la izquierda, y r desde la derecha Se realiza un intercambio cuando l está en un elemento mayor que el pivote y r está en uno menor al pivote.

51 In Place Quick Sort (contd.) Un intercambio con el pivote completa el paso dividir cuando r < l

52 Algoritmo rápido (Quicksort) void qsort(int izq, int der, int a[]) { int i, ult, m, tmp; if (izq >= der) return; tmp= a[izq]; m= (izq+der)/2; a[izq]= a[m]; a[m]=tmp; ult=izq; for (i=izq+1;i<=der;i++) if (a[i] < a[izq]) { tmp= a[++ult]; a[ult]= a[i]; a[i]=tmp; } tmp= a[izq]; a[izq]= a[ult]; a[ult]=tmp; qsort(izq,ult-1,a); qsort(ult+1,der,a); }

53 Ordenación directa por base (radix sort) A diferencia de otros métodos, radix sort considera la estructura de las llaves. Se asume que las llaves están representadas en un sistema de numeración M (M=radix), e.g., si M=2, las llaves están representadas en binario. Toma ventaja de la posición de cada dígito individual en la clave. Hay dos versiones de la ordenación radix: MSD (most significant digit), LSD (least significant digit). La ordenación se realiza comparando los bits en cada posición.

54 Ejemplo Radix sort Conjunto a ordenar: { 33, 60, 5, 15, 25, 12, 45, 70, 35, 7} frente cola cola_digitos[0] cola_digitos[1] cola_digitos[2] 12 cola_digitos[3] 33 cola_digitos[4] cola_digitos[5] cola_digitos[6] cola_digitos[7] 7 cola_digitos[8] cola_digitos[9]

55 Ejemplo Radix sort Conjunto a ordenar: { 33, 60, 5, 15, 25, 12, 45, 70, 35, 7} frente cola cola_digitos[0] cola_digitos[1] 12 cola_digitos[2] 25 cola_digitos[3] cola_digitos[4] cola_digitos[5] 45 cola_digitos[6] 60 cola_digitos[7] 70 cola_digitos[8] cola_digitos[9]

56 Radix sort directo Se examinan los bits de derecha a izquierda for k=0 to b-1 ordenar el array de forma estable tomando solo el bit k

57 Radix sort en enteros La ordenación resultante es estable:

58 Análisis de Tiempo de Ejecución Los algoritmos de burbuja, inserción, selección corren en O(n 2 ). El algoritmo quicksort, montones corren en O(nlogn) El algoritmo radix sort es O(n)