Anlisis de la complejidad computacional de los algoritmos de ordenacin

INSERCION
Insercion(int matrix[]) { int i, temp, j; for (i = 1; i < matrix.length; i++) { temp = matrix[i]; j = i - 1; while ( (matrix[j] > temp) && (j >= 0) ) { matrix[j + 1] = matrix[j]; j--; } matrix[j + 1] = temp; } }
EN LA CLASE: ANALIZA EL TIEMPO DE EJECUCIN _ COMPLEJIDAD

SELECCION
Seleccion(int[]matrix) { int i, j, k, p, buffer, limit = matrix.length-1; for(k = 0; k < limit; k++) { p = k; for(i = k+1; i <= limit; i++) if(matrix[i] < matrix[p]) p = i; if(p != k) { buffer = matrix[p]; matrix[p] = matrix[k]; matrix[k] = buffer; } } }
EN LA CLASE: ANALIZA EL TIEMPO DE EJECUCIN _ COMPLEJIDAD

Algoritmo quicksort
La primera etapa en el algoritmo de particin es obtener el elemento pivote; Una vez que se ha seleccionado se ha de buscar el sistema para situar en la sublista izquierda todos los elementos menores que el pivote y en la sublista derecha todos los elementos mayores que el pivote. Supongamos que todos los elementos de la lista son distintos, aunque ser preciso tener en cuenta los casos en que existan elementos idnticos

 El primer problema a resolver en el diseo del algoritmo de quicksort es seleccionar el pivote. Aunque la posicin del pivote, en principio, puede ser cualquiera, una de las decisiones ms ponderadas es aquella que considera el pivote como el elemento central o prximo al central de la lista Veamos el siguiente ejemplo

Los pasos que sigue el algoritmo quicksort:

Seleccionar el elemento central de a[0:n-1] como pivote Dividir los elementos restantes en particiones izquierda y derecha, de modo que ningn elemento de la izquierda tenga una clave (valor) mayor que el pivote y que ningn elemento a la derecha tenga una clave ms pequea que la del pivote. Ordenar la particin izquierda utilizando quicksort recursivamente. Ordenar la particin derecha utilizando quicksort recursivamente. La solucin es particin izquierda seguida por el pivote y a continuacin particin derecha.

Codificacin en C del algoritmo quicksort

void quicksort(double a[], int primero, int ultimo) { int i, j, central; double pivote; central = (primero + ultimo)/2; pivote = a[central]; i = primero; j = ultimo; do { while (a[i] < pivote) i++; while (a[j] > pivote) j--; if (i<=j) { double tmp; tmp = a[i]; a[i] = a[j]; a[j] = tmp; /* intercambia a[i] con a[j] */ i++; j--; } }while (i <= j); if (primero < j) quicksort(a, primero, j);/* mismo proceso con sublista izqda */ if (i < ultimo) quicksort(a, i, ultimo); /* mismo proceso con sublista drcha */ }

Anlisis del algoritmo quicksort

El anlisis general de la eficiencia de quicksort es difcil. La mejor forma de ilustrar y calcular la complejidad del algoritmo es considerar el nmero de comparaciones realizadas teniendo en cuenta circunstancias ideales. Supongamos que n (nmero de elementos de la lista) es una potencia de 2,

n = 2k (k = log2 n).
Adems, supongamos que el pivote es el elemento central de cada lista, de modo que quicksort divide la sublista en dos sublistas aproximadamente iguales. En la primera exploracin o recorrido hay n 1 comparaciones. El resultado de la etapa crea dos sublistas aproximadamente de tamao n/2. En la siguiente fase, el proceso de cada sublista requiere aproximadamente n/2 comparaciones. Las comparaciones totales de esta fase son 2(n/2) = n. La siguiente fase procesa cuatro sublistas que requieren un total de 4(n/4) comparaciones, etc.

Eventualmente, el proceso de divisin termina despus de k pasadas cuando la sublista resultante tenga tamao 1. El nmero total de comparaciones es aproximadamente: n + 2(n/2) + 4(n/4) + + n(n/n) = n + n + + n = n k = n log2 n Para una lista normal la complejidad de quicksort es O(n log2 n) El caso ideal que se ha examinado se realiza realmente cuando la lista (el array) est ordenado en orden ascendente. En este caso el pivote es precisamente el centro de cada sublista.

Si el array est en orden ascendente, el primer recorrido encuentra el pivote en el centro de la lista e intercambia cada elemento en las sublistas inferiores y superiores. La lista resultante est casi ordenada y el algoritmo tiene la complejidad O(n log2 n)

El escenario del caso peor de quicksort ocurre cuando el pivote cae consistentemente en una sublista de un elemento y deja el resto de los elementos en la segunda sublista. Esto sucede cuando el pivote es siempre el elemento ms pequeo de su sublista.

En el recorrido inicial, hay n comparaciones y la sublista grande contiene n 1 elementos.

En el siguiente recorrido, la sublista mayor requiere n 1 comparaciones y produce una sublista de n 2 elementos, etc. El nmero total de comparaciones es: n + n 1 + n 2 + + 2 = (n 1)(n + 2)/2 La complejidad es O(n2). En general el algoritmo de ordenacin tiene como complejidad media O(n log2 n) siendo posiblemente el algoritmo ms rpido

ORDENACIN POR MEZCLA

En este caso se sigue un esquema similar a la ordenacin rpida, el esquema de divide y vencers. Sin embargo el mayor esfuerzo no se realiza dividiendo el vector y reorganizando cada divisin, sino que tiene lugar cuando finalmente se construye el vector ordenado a partir de la mezcla de los subvectores que se generan.
La idea consiste en dividir el vector v en dos subvector es para posteriormente mezclar ordenadamente las soluciones obtenidas al ordenar A y B, aplicando nuevamente el algoritmo Merge Sort a ambos subvectores.

PSEUDOCDIGO

Si v es de tamao 1 entonces el vector v ya est ordenado sino dividir v en dos subvectoresA y B fin {si} Ordenar A y B usando Mergesort Mezclar las ordenaciones de A y B para generar el vector ordenado. Donde dividir v en dos subvectores se puede refinar: Asignar a A el subvector[v1,.....,vnDIV2] Asignar a B el subvector[vnDIV2+1,......vn] Mientras que mezclar las ordenaciones de A y B consiste en ir entremezclando adecuadamente las componentes ya ordenadas de A y B.

UN EJEMPLO
V=[8,5,7,3] 1. Mergedesdehasta(v,1,4)centro=2 1.1. Izq(1) <centro(2) Mergedesdehasta(v,1,2) centro=1 1.1.1. izq(1) not< centro(1) 1.1.2. centro(1)< der(2) 1.1.2.1 izq(2) not< centro(2) 1.1.2.2. centro(2) not< der(2) 1.1.2.3. Merge(v,2,2,2,v) trivial Merge(v1,1,2,v)--------w1[5,8]

1.2. Centro(2) < der(4) Mergedesdehasta(v,3,4) centro=3 1.2.1. izq(3) not< centro(3) 1.2.2. centro(3) < der(4) 1.2.2.1. izq(4) not< centro(4) 1.2.2.2. centro(4) not< der(4) 1.1.2.3. Merge(v,4,4,4,v) trivial Merge(v3,3,4,v)--------w2[3,7] 1.3. Merge(v,1,2,4,v)------------w[3,5,7,8] Mezcla ordenada de w1 y w2

CLCULO DE SU COMPLEJIDAD ALGORTMICA

El peor caso: Puesto que la mezcla se ejecuta en un tiempo proporcional a n (la longitud del vector a ordenar) el coste en tiempo vendr dado por la siguiente recurrencia:

Esta ecuacin se resuelve mediante sustituciones sucesivas cuando n es una potencia de 2 (j tal que n=2j).

De donde sustituyendo jlog n lo que da una funcin de orden O(n logn) (una vez aplicadas las reglas de la suma y de la escalabilidad)

TAREA DE ENTRENAMIENTO
REALIZAR EL ANALISIS DE TIEMPO DE EJECUCION ORDEN DE COMPLEJIDAD (PARA LOS CASOS PEOR, MEJOR, MEDIO) DE LOS ALGORITMOS: HEAPSORT Y ALGORITMOS DE BUSQUEDA: B. SECUENCIAL B. BINARIA ITERATIVA B. BINARIA RECURSIVA