Algoritmos de Bsqueda y Ordenacin.

Rosala Laza Fidalgo. Departamento de Informtica. Universidad de Vigo

Complejidad
Cmo podemos medir y comparar algoritmos, si estos se ejecutan a distintas velocidades y requieren diferentes cantidades de espacio segn en qu ordenador se ejecuten, y con qu lenguaje de programacin (o compilador) hayan sido implementados? Con la simple recogida de los tiempos de ejecucin de los algoritmos indudablemente no.
Tamao del array n 125 250 500 1000 2000 Ordenador A (ms) 12.5 Ordenador B (ms) 2.8

49.3

11.0

195.8

43.4

780.3

172.9

3114.9

690.5

Complejidad
3500 Tiempo de Ejecucin 3000 2500 2000 1500 1000 500 0 125 250 500 T am a o 1000 2000 f 1(n) f 2(n)

f1(n) = 0,0007772n2+0,00305n+0,001

f2(n)=0,0001724n2+0,00400n+0,100

Independientemente de la mquina, el lenguaje de programacin o el compilador que se haya utilizado para la ejecucin del algoritmo A, el tiempo de ejecucin que consume dicho algoritmo SIEMPRE dar lugar a una funcin cuadrtica del tamao del array que trate. Es decir, la forma de la curva ser la misma.

Notacin O.
Los tiempos de ejecucin para diferentes algoritmos dan lugar a diferentes clases de complejidad. Cada clase de complejidad se caracteriza por una familia de curvas distinta. Todas las curvas de una clase de complejidad concreta tienen la misma forma bsica, pues solo se diferencian entre ellas por el valor de sus constantes. La notacin O (tambin llamada O mayscula), se utiliza para comparar la eficiencia de los algoritmos. La notacin O se centra en el trmino dominante an2 (es decir, en aquel que ms crece cuando n aumenta; tal y como se observa en la Tabla2), e ignora el resto de trminos. Por lo tanto, desprecia tambin la constante de proporcionalidad a. As:
O(an2 + bn + c) = O(an2) = O(n2)

f(n)=an2+bn+c
donde a = 0,0001724, b = 0,00400, c = 0,1

f(n)

an2

Trmino n2 como % del total

125 250 500 1000 2000

2.8 11.0 43.4 172.9 690.5

2.7 10.8 43.1 172.4 689.6

94.7 98.2 99.3 99.7 99.9

Propiedades Notacin O
O( f(x) ) + k O( k f(x) ) O( f(x) ) * O( g(x) ) O( f(x) ) + O( g(x) ) g(x) ) ) = = = = O( f(x) ) O( f(x) ) O( f(x) * g(x) ) max ( O( f(x) ), O(

Complejidad de Sentencias en Java

REGLA 1 - CICLOS FOR: El tiempo de ejecucin de un ciclo for es, como mximo, el tiempo de ejecucin de las instrucciones que estn en el interior del ciclo (incluyendo las condiciones) por el nmero de iteraciones. Se supone que las sentencias simples tienen un tiempo de ejecucin constante. REGLA 2 - CICLOS FOR ANIDADOS: Analizarlos de adentro hacia afuera. El tiempo de ejecucin total de una proposicin dentro del grupo de ciclos for anidados es el tiempo de ejecucin de la proposicin multiplicado por el producto de los tamaos de todos los ciclos for. REGLA 3 - PROPOSICIONES CONSECUTIVAS: Simplemente se suman REGLA 4 - CONDICION IF THEN /ELSE: if (expresin) instruccin1 else instruccin2 su tiempo de ejecucin nunca es ms grande que el tiempo de ejecucin de la expresin ms el mayor de los tiempos de ejecucin de la instruccin1 y la instruccin2.

Complejidad de un Algoritmo
A continuacin se muestra un ejemplo de clculo de subsecuencia de suma mxima resuelto de tres formas diferentes y cmo influye su resolucin en la complejidad del algoritmo. Dada la secuencia de enteros (posiblemente negativos) A1, A2, ..., An, encontrar (e identificar la subsecuencia correspondiente) el valor mximo de j k=i Ak. Cuando todos los enteros son negativos entenderemos que la subsecuencia de suma mxima es la vaca, siendo su suma cero.
Por ejemplo para la entrada {-2, 11, -4, 13, -5, 2}, la respuesta es 20. Y para {-2, 11, 1}, la respuesta es 12. Se marca en negrita la subsecuencia de suma mxima

Subsecuencia de suma mxima I

public static int subsecuenciaSumaMaxima (int { int sumaMax = 0; for (int i = 0; i < a.length; i++) for (int j = i; j < a.length; j++) { int sumaActual = 0; for (int k = i; k <= j; k++) sumaActual += a [k]; if (sumaActual > sumaMax) [] a) O(n) O(n) O(1) O(n) O(1) O(n) O(1)

O(n3)

sumaMax = sumaActual; } return sumaMax; } O(1)

Complejidad: O(1) + O(n3) + O(1) =

O (n3)

Subsecuencia de suma mxima II

En el algoritmo anterior el bucle ms interno es exageradamente costoso. Una vez que hemos calculado la suma de la subsecuencia que se extiende desde i hasta j-1, calcular la suma que va desde i hasta j no debera llevar mucho tiempo, es simplemente una suma ms, sin embargo el algoritmo cbico no utiliza esta informacin.

Subsecuencia de suma mxima II

public static int subsecuenciaSumaMaxima (int [] a) { int sumaMax = 0; for (int i = 0; i < a.length; i++) { int sumaActual = 0; O(1) for (int j = i; j < a.length; j++) O(n) { sumaActual += a [j]; if (sumaActual > sumaMax) sumaMax = sumaActual; } } return sumaMax; } Complejidad: O(1) + O(n2) + O(1) = O(1) O(1) O(n)

O(n2) O(n)

O (n2)

Subsecuencia de suma mxima III

Cuando se detecta una subsecuencia negativa, no slo podemos salir del bucle interno del algoritmo anterior, sino que se puede avanzar i hasta j+1.

Subsecuencia de suma mxima III

public static int subsecuenciaSumaMaxima (int [] a) { int sumaMax = 0; int sumaActual = 0; for (j = 0; j < a.length; j++) { sumaActual += a [j]; if (sumaActual > sumaMax) sumaMax = sumaActual; O(1) else if (sumaActual < 0) { sumaActual = 0; } O(1) O(n) O(1) O(1)

O(n)

return sumaMax; }

Complejidad: O(1) + O(1) + O(n) + O(1) =

O (n)

Notacin O (de menor a mayor)

FUNCIN Constante Logartmica Lineal Logartmica Cuadrtica Cbica Exponencial Exponencial O(1) O(log n) O(n) O(n log n) O(n2) O(n3) O(2n) O(10n) NOTACIN O

Complejidad logartmica
En la complejidad logartmica no se tiene en cuenta la base, porque un cambio entre bases slo implica multiplicar por una constante. Log10n = log2n / log210 1/log210 = 0.301 Log10n = 0.301 * log2n

Complejidad Logartmica
Es adecuado implementar algoritmos con una complejidad logartmica, porque los logaritmos crecen muy lentamente aunque el nmero de datos aumente considerablemente. Se define formalmente un logaritmo para cualquier b, n > 0, como: Los logaritmos crecen lentamente. Ej. Un logaritmo de un milln es aproximadamente 20, y el algoritmo de un billn es aproximadamente 40.
Logbn = k si bk=n

Logb n = k si bk=n

Ejemplos de complejidad logartmica

BITS EN UN NMERO BINARIO. Cuntos bits son necesarios para representar N enteros consecutivos? Sabiendo que, un entero short de 16 bits representa 65.536 enteros (32.768 a 32.767) = 216. Se puede afirmar que con K bits se representan aproximadamente 2K enteros. 2K=N, por lo que se puede concluir que K=log2 N, por lo tanto el nmero de bits mnimo es log N. Para representar N enteros consecutivos son necesarios log N bits.

Logb n = k si bk=n

Ejemplos de complejidad logartmica

DUPLICACIONES REPETIDAS. Empezando con X=1, cuntas veces debe ser X duplicado antes de que sea mayor que N? Empezando en 1 se puede duplicar un valor repetidamente solamente un nmero de veces logartmico antes de alcanzar N.
N de Veces que se duplica Valor de X 1 2 3 p

Valor de X

21

22

23

2p

El nmero de veces que se duplica es p. 2p = N, es decir p = log2 N. Por lo tanto se duplica un nmero logartmico de veces.

Logb n = k si bk=n

Ejemplos de complejidad logartmica

DIVISIONES A LA MITAD. Empezando con X=N, si N se divide de forma repetida por la mitad cuntas veces hay que dividir para hacer N menor o igual a 1?
N de Veces que se divide N de datos 1 2 3 p

N/2

N/4

N/8

N/N

N de datos

N/21

N/22

N/23

N/2p

El nmero de veces que se divide es p. 2p = N, es decir p = log2 N. Por lo tanto se divide N hasta llegar a 1 un nmero logartmico de veces.

Consideraciones sobre la eficiencia de un programa.

Para resolver un problema debemos encontrar un algoritmo que tenga una complejidad lo ms pequea posible. Si dudamos entre dos algoritmos de la misma complejidad podemos calcular la complejidad en media. Si un programa va a ser usado con una cantidad de datos pequea, la notacin O no es muy significativa. En este caso, si es posible, se puede acudir al tiempo medio. Los accesos a memoria secundaria suelen ser muy lentos. Deben, por tanto, reducirse a los imprescindibles.

Consideraciones sobre la eficiencia de un programa.

public boolean Pertenece1 (int [] A, int X) { int i; boolean encontrado = false; for (i = 0; i < A.length; i++) { if (A[i] ==X) encontrado = true; } return encontrado; } Tiempo de Ejecucin mtodo Pertenece1

O(n)

Consideraciones sobre la eficiencia de un programa.

public boolean Pertenece2 (int [] A, int X) { int i = 0; while (i < A.length - 1 && A[i] != X) i++; return A[i] == X; } Tiempo de Ejecucin mtodo Pertenece2

O(n)

Consideraciones sobre la eficiencia de un programa.

public boolean Pertenece1 (int [] A, int X) { int i; boolean encontrado = false; for (i = 0; i < A.length; i++) { if (A[i] ==X) encontrado = true; } return encontrado; } public boolean Pertenece2 (int [] A, int X) { int i = 0;

while (i < A.length - 1 && A[i] != X) i++; return A[i] == X;

}

Nmero de iteraciones? Pertenece1 --------- La media es n. Pertenece2 --------- La media es n/2.

Bsqueda Interna
El problema de la bsqueda es un problema de recuperacin de la informacin lo ms rpidamente posible y consiste en localizar un elemento en una lista o secuencia de elementos. La operacin de bsqueda puede llevarse a cabo sobre elementos ordenados o sobre elementos desordenados. Bsqueda interna si todos los elementos se encuentran en memoria principal (por ejemplo, almacenados en arrays, vectores o listas enlazadas) Bsqueda externa si los elementos se encuentran en memoria secundaria.

Bsqueda Interna
Definicin en Java de un array.
//declaracin de un array de tipo_elemento tipo_elemento [] array; //reserva de espacio para almacenar los datos en el array array = new tipo_elemento[n];

Cada algoritmo de bsqueda trata de localizar en un array un elemento X. Una vez finalizada la bsqueda puede suceder:

que la bsqueda haya tenido xito, habiendo localizado la posicin donde estaba almacenado el elemento X, o que la bsqueda no haya tenido xito, concluyndose que no exista ningn elemento X.

Bsqueda Lineal
Es la forma ms simple de buscar un elemento y consiste en examinar secuencialmente uno a uno hasta encontrar el buscado o haber revisado todos los elementos sin xito.
public static int busquedaLineal(int X, int [] A) { int i = 0; int n = A.length -1; while (i < n && A[i] != X) i++; /* Si se encuentra el elemento se devuelve su posicin sino se devuelve -1 (indica que el elemento no est)*/ if (A[i] == X) return i; else return -1;

Complejidad Bsqueda Lineal

MEJOR CASO: Si tenemos mucha suerte, puede ser que la primera posicin examinada contenga el elemento que buscamos, en cuyo caso el algoritmo informar que tuvo xito despus de una sola comparacin. Por tanto, su complejidad ser O(1). PEOR CASO: Sucede cuando encontramos X en la ltima posicin del array. Como se requieren n ejecuciones del bucle mientras, la cantidad de tiempo es proporcional a la longitud del array n, ms un cierto tiempo para realizar las condiciones del bucle mientras y para la llamada al mtodo. Por lo tanto, la cantidad de tiempo es de la forma an + b para ciertas constantes a y b. En notacin O, O(an+b) = O(an) = O(n). CASO MEDIO: Supongamos que cada elemento almacenado tiene la misma probabilidad de ser buscado. La media se puede calcular tomando el tiempo total de encontrar todos los elementos y dividindolo por n: Total = a (1 + 2 + ...+n) + bn = a (n(n+1) / 2) + bn Media = (Total / n) = a((n+1) / 2) + b que es O(n).

Bsqueda Binaria
Si los elementos sobre los que se realiza la bsqueda estn ordenados, entonces podemos utilizar un algoritmo de bsqueda mucho ms rpido que el secuencial, la bsqueda binaria. Consiste en reducir paulatinamente el mbito de bsqueda a la mitad de los elementos, basndose en comparar el elemento a buscar con el elemento que se encuentra en la mitad del intervalo y en base a esta comparacin:

Si el elemento buscado es menor que el elemento medio, entonces sabemos que el elemento est en la mitad inferior de la tabla. Si es mayor es porque el elemento est en la mitad superior. Si es igual se finaliza con xito la bsqueda ya que se ha encontrado el elemento.

Cdigo Bsqueda Binaria

public static int busquedaBinaria(int X, int [] A){ int inicio = 0; int fin = A.length -1; int medio; while (inicio <= fin) { medio = (inicio+fin)/2; if (A[medio] < X) inicio = medio+1; else } if (A[medio] > X) fin = medio -1; else return medio;

return -1; }

Cdigo recursivo Bsqueda Binaria

public static int binariaRec(int [] A, int X, int inicio, int fin) { int medio; if (inicio > fin) return -1; else { medio = (inicio+fin)/2; if (A[medio] < X) return binariaRec(A,X,medio+1,fin); else if (A[medio] > X) return binariaRec(A,X,inicio,medio -1); else return medio; } }

Complejidad Bsqueda Binaria

CASO PTIMO: La bsqueda binaria requiere slo una comparacin; esto significa que su tiempo de ejecucin ptimo no depende de la cantidad de datos: es constante y por tanto proporcional a 1, es decir, O(1). PEOR CASO: En el peor caso s dependen de N. La bsqueda binaria divide el array, requiriendo slo un tiempo O(log n). El algoritmo de bsqueda binaria progresivamente va disminuyendo el nmero de elementos sobre el que realizar la bsqueda a la mitad: n, n/2, n/4, ... As, tras log2n divisiones se habr localizado el elemento o se tendr la seguridad de que no estaba.

Bsqueda Indexada
Necesita que los elementos sobre los que se realiza la bsqueda estn ordenados de acuerdo a una determinada clave. El mtodo utiliza un array auxiliar denominado array ndice. Cada objeto en el array ndice consta de un valor y la posicin que ocupa dicho valor en el correspondiente array ordenado: En Java se define como se muestra a continuacin: class ElemIndice{ private int clave; private int posicion; public ElemIndice(int c, int p){ clave=c; posicion=p;} public int getClave(){ return clave; } public int getPosicion(){ return posicion; }

Bsqueda Indexada
Mediante cada elemento del array ndice se asocian grupos de elementos del array inicial. Los elementos en el ndice y en el array deben estar ordenados. El mtodo consta de dos pasos:
1. 2.

La ventaja del mtodo estriba en que la bsqueda se realiza inicialmente en el array de ndices, cuantitativamente ms pequea que el array de elementos. Cuando se ha encontrado el intervalo correcto, se hace una segunda bsqueda en una parte reducida del array. Estas dos bsquedas pueden ser secuenciales o binarias y el tiempo de ejecucin depender del tipo de bsqueda utilizado en cada uno de los arrays

Buscar en el array_ndice el intervalo correspondiente al elemento buscado. Restringir la bsqueda a los elementos del intervalo que se localiz previamente.

Ejemplo de Bsqueda Indexada

3 4 5 6 7 8 9 10 14 16 19

Se decide dividir el array inicial en bloques de tres elementos. El array ndice estar formado por n/k + 1 elementos, por no ser el ltimo bloque de igual tamao, es decir, 11/3 +1= 4
Clave Posicin

3 0

6 3

9 6

16 9

Ejemplo de Bsqueda Indexada

3 4 5 6 7 8 9 10 14 16 19

Se puede implementar la bsqueda binaria en el array de ndices. Cuando finaliza la bsqueda, o ha encontrado el elemento buscado o est en la posicin que contiene al elemento mayor de los ms pequeos al elemento buscado Si X = 10, en el array de ndice indicar la posicin 2. Por lo tanto, la bsqueda en el array inicial comenzar en la posicin 6 hasta el final del bloque.

Clave Posicin

3 0

6 3

9 6

16 9

Cdigo para crear el array de ndices

public ElemIndice [] crearArrayIndice(int k){ int n_indices; int n = A.length; if (n%k == 0) n_indices = n/k; else n_indices = n/k + 1; ElemIndice [] arrayIndice = new ElemIndice[n_indices]; int cont = 0; for (int i = 0; i<n_indices; i++) { array_indice[i]= new ElemIndice(A[cont],cont); //cont apunta al primer elemento de cada bloque del array grande cont += k; } } return arrayIndice;

Ejercicio
Implementa los algoritmos de bsqueda indexada usando la bsqueda binaria tanto en el array de ndices como en el array inicial. public int Bus_Binaria_array_indice(Elem_indice [] array_indice, int X){ int inicio = 0; int fin = array_indice.length -1; int medio; while (inicio <= fin) { medio = (inicio+fin)/2; if (array_indice[medio].getClave() < X) inicio = medio+1; else if (array_indice[medio].getClave() > X) fin = medio -1; else return array_indice[medio].getPosicion();

//Caso especial el elemento buscado es ms pequeo que el primer elemento

if (fin == -1) return -1; else return array_indice[fin].getPosicion();

//Busqueda Binaria array public int Bus_Binaria_array(int [] A, Elem_indice [] array_indice, int X, int k){ int i = Bus_Binaria_array_indice(array_indice, X); if (i != -1){ int f = i+k-1; if (f >= A.length) f=A.length-1; while (i <= f) { int medio = (i+f)/2; if (A[medio] < X) i = medio+1; else if (A[medio] > X) f = medio -1; else return medio; } // fin while }// fin if return -1; }

Otra propuesta para crear el array de Indices de la Bsqueda Indexada.

/* El array de ndices slo almacena el primer elemento de cada bloque, su posicin en el array grande se obtiene multiplicando la posicin del array de ndices por K*/ public int [] crearArrayIndice(int k){ int n_indices; int n = A.length; if (n%k == 0) n_indices = n/k; else n_indices = n/k + 1; int [] arrayIndice = new int[n_indices]; int cont = 0; for (int i = 0; i<n_indices; i++) { array_indice[i]= A[cont]; cont += k; } return arrayIndice;

Bsqueda mediante Hashing

Existe un mtodo que puede aumentar la velocidad de bsqueda donde los datos no necesitan estar ordenados y esencialmente es independiente del nmero n. Este mtodo se conoce como transformacin de claves o hashing. El hashing consiste en convertir el elemento almacenado (numrico o alfanumrico) en una direccin (ndice) dentro del array. La idea general de usar la clave para determinar la direccin del registro es una excelente idea, pero se debe modificar de forma que no se desperdicie tanto espacio. Esta modificacin se lleva a cabo mediante una funcin que transforma una clave en un ndice de una tabla y que se denomina funcin de Randomizacin o Hash. Si H es una funcin hash y X es un elemento a almacenar, entonces H(X) es la funcin hash del elemento y se corresponde con el ndice donde se debe colocar X.

Bsqueda mediante Hashing

El mtodo anterior tiene una deficiencia: suponer que dos elementos X e Y son tales que H(X) = H(Y). Entonces, cuando un el elemento X entra en la tabla, ste se inserta en la posicin dada por su funcin Hash, H(X). Pero cuando al elemento Y le es asignado su posicin donde va a ser insertado mediante la funcin hash, resulta que la posicin que se obtiene es la misma que la del elemento X. Esta situacin se denomina Randomizacin o Hashing con colisin o choque. Una buena funcin Hash ser aquella que minimice los choques o coincidencias, y que distribuya los elementos uniformemente a travs del array. Esta es la razn por la que el tamao del array debe ser un poco mayor que el nmero real de elementos a insertar, pues cuanto ms grande sea el rango de la funcin de randomizacin, es menos probable que dos claves generen el mismo valor de asignacin o hash, es decir, que se asigne una misma posicin a ms de un elemento.

Mtodos de Transformacin de claves

TRUNCAMIENTO: Ignora parte de la clave y se utiliza la parte restante directamente como ndice. Si las claves, por ejemplo, son enteros de 8 dgitos y la tabla de transformacin tiene 100 posiciones, entonces el 1, 2 y 5 dgitos desde la derecha pueden formar la funcin hash. Por ejemplo, 72588495 se convierte en 895. El truncamiento es un mtodo muy rpido, pero falla para distribuir las claves de modo uniforme. MTODO DE DIVISIN: Se escoge un nmero m mayor que el nmero n de elementos a insertar, es decir, el array posee ms posiciones que elementos a insertar. La funcin hash H se define por: H(X) = X % m o H(X) = (X % m) + 1 donde X % m indica el resto de la divisin de X por m. La segunda frmula se usa cuando queremos que las direcciones hash vayan de 1 a m en vez de desde 0 hasta m-1. El mejor resultado del mtodo de divisin se obtiene cuando m es primo (es decir, m no es divisible por ningn entero positivo distinto de 1 y m).

Mtodos de Transformacin de claves

MTODO DEL MEDIO DEL CUADRADO: La clave es multiplicada por s misma y los dgitos del medio (el nmero exacto depende del rango del ndice) del cuadrado son utilizados como ndice. MTODO DE SUPERPOSICIN: Consiste en la divisin de la clave en diferentes partes y su combinacin en un modo conveniente (a menudo utilizando suma o multiplicacin) para obtener el ndice. La clave X se divide en varias partes X1, X2, ..., Xn, donde cada una, con la nica posible excepcin de la ltima, tiene el mismo nmero de dgitos que la direccin especificada. A continuacin, se suman todas las partes. En esta operacin se desprecian los dgitos ms significativos que se obtengan de arrastre o acarreo. Hay dos formas de conseguir la funcin hash mediante este mtodo:
1. 2.

superposicin por desplazamiento donde todas las partes se suman entre s. superposicin por plegado se hace la inversa a las partes pares, X2, X4, ..., antes de sumarlas, con el fin de afinar ms.

Ejemplos de Transformacin de claves

Supongamos un array con 100 posiciones para guardar las claves de los empleados. Aplica las funciones hash anteriores para cada uno de los empleados: 3205 7148 2345. Mtodo de la divisin: Escojo un n primo prximo a 100 (m = 97). Aplico la funcin Hash H(X) = X % m.
H(3205) = 4, H(7148) = 67, H(2345) = 17.

Mtodo del medio del cuadrado: Se escogen el 4 y el 5 dgitos por la derecha par obtener la dir. Hash
K: 3205 K2:10272025 7148 51093904 2345 5499025

Ejemplos de Transformacin de claves

Mtodo de Superposicin:
Por desplazamiento:
H(3205) = 32+05 = 37 H(7148) = 71+48 = 19 H(2345) = 23+45 = 68

Por plegado:
H(3205) = 32+50 = 82 H(7148) = 71+84 = 55 H(2345) = 23+54 = 77

Soluciones al problema de las colisiones

Supongamos que queremos aadir un nuevo elemento k, pero la posicin de memoria H(k) ya est ocupada. Esta situacin se llama colisin. Para resolver las colisiones se utilizan los siguientes mtodos:
Rehashing o Reasignacin. Encadenamiento o Tablas Hash Abiertas. Zona de Desbordamiento.

Soluciones al problema de las colisiones

Un factor importante en la eleccin del procedimiento a utilizar es la relacin entre el nmero n de elementos y el nmero m de tamao del array. Conocido como factor de carga, =n/m. La eficiencia de una funcin hash con un procedimiento de resolucin de colisiones se mide por el nmero medio de pruebas (comparaciones entre elementos) necesarias para encontrar la posicin de un elemento X dado. La eficiencia depende principalmente del factor de carga . En concreto, interesa conocer:
S() = n medio de celdas examinadas para una bsqueda CON xito U() = n medio de celdas examinadas para una bsqueda SIN xito.

Rehasing o Reasignacin
Se trata de insertar o buscar un elemento cuya posicin ya est ocupada, en otra posicin disponible en la tabla. Esto se hace mediante la funcin de reasignacin R(H(X)), la cual acepta un ndice de la tabla y produce otro. Mtodos de reasignacin:
Prueba lineal Prueba cuadrtica Doble direccin hash

Reasignacin. Prueba Lineal

Consiste en que una vez detectada la colisin se debe recorrer el array secuencialmente a partir del punto de colisin, buscando al elemento. El proceso de bsqueda concluye cuando el elemento es hallado, o bien cuando se encuentra una posicin vaca. Se trata al array como a una estructura circular: el siguiente elemento despus del ltimo es el primero. La funcin de rehashing es, por tanto, de la forma: R(H(X)) = (H(X) + 1) % m

Cdigo Prueba Lineal

public static int pruebaLineal(int X, int[] A){ int m = A.length; int dirHash = X%m; if (A[dirHash] == X) return dirHash; else { int dirReh = (dirHash + 1)%m; while ((A[dirReh] != X) && (A[dirReh] != 0) && (dirReh != dirHash)) dirReh = (dirReh + 1)%m; /* Se ha encontrado el elemento buscado*/ if (A[dirReh] == X) return dirReh; else return -1; }

Complejidad Prueba Lineal

Utilizando este mtodo de resolucin de colisiones, el nmero medio de pruebas para una bsqueda CON xito es: S() = (1+ ( 1 / (1-) )) y el nmero medio de pruebas para una bsqueda SIN xito es: U() = (1+ (1 / (1-)2 )) La principal desventaja de este mtodo es que puede haber un fuerte agrupamiento alrededor de ciertas claves, mientras que otras zonas del array permanezcan vacas. Si las concentraciones de claves son muy frecuentes, la bsqueda ser principalmente secuencial perdiendo as las ventajas del mtodo hash. Una solucin es que la funcin hash acceda a todas las posiciones de la tabla, pero no de una en una posicin sino avanzando varias posiciones.

Rehasing, mejora
para cualquier funcin R(H(i))=(i+c) % m, donde m es el nmero de elementos de la tabla y c es una constante tal que c y m son primos relativos (es decir, no tienen factores en comn), genera valores sucesivos que cubren toda la tabla. Sin embargo, si m y c tienen factores en comn, el nmero de posiciones diferentes de la tabla que se obtienen ser el cociente de dividir m entre c. Basndonos en esta ltima afirmacin, el algoritmo de bsqueda (y el de carga) tienen un problema: utilizando una funcin de rehashing de este tipo podran salir sin insercin aun cuando exista alguna posicin vaca en la tabla
Ejemplo: Dada la funcin de reasignacin: RH(i) = ( i + 200 ) % 1000 posiciones posibles: (1000/200= 5)

Para evitar que la Prueba Lineal se convierta en una bsqueda Lineal: Se cumple que,

Con esta funcin, cada clave solo puede ser colocada en cinco

si i = 215, y esta posicin est ocupada, entonces se reasigna de la siguiente forma: RH(215)=(215+200) %1000 = 415 RH(415)=(415+200) %1000 = 615 RH(615)=(615+200) %1000 = 815 RH(815)=(815+200) %1000 = 15 RH(15)=( 15+200) %1000 = 215 RH(215)=(215+200) %1000 = 415 ........................... Si estas cinco posiciones posibles estn ocupadas, saldremos sin insercin aun cuando haya posiciones libres en la tabla.

Rehasing: Agrupamiento o clustering

A pesar de la utilizacin de una funcin de rehashing donde c y m sean primos, con el mtodo de prueba lineal los elementos siguen tendiendo a agruparse, o sea, a aparecer unos junto a otros, cuando el factor de carga es mayor del 50%. Cuando la tabla est vaca es igualmente probable que cualquier elemento al azar sea colocado en cualquier posicin libre dentro de la tabla. Pero una vez que se han tenido algunas entradas y se han presentado varias colisiones en la asignacin, esto no es cierto.

Ejemplo de Agrupamiento
Clave 4618396 4957397 1286399 ndice 396 397 398 399 400 401 0000990 0000991 1200992 0047993 9846995 990 991 992 993 994 995
En este caso, es cinco veces ms probable que un registro sea insertado en la posicin 994 que en la posicin 401. Esto se debe a que cualquier registro cuya clave genera la asignacin 990, 991, 992, 993 o 994 ser colocado en la 994, mientras que cualquier registro cuya clave genera la asignacin 401 ser colocado en su posicin. Este fenmeno en el que dos claves que inicialmente generan una asignacin en dos sitios diferentes, luego compiten entre s en reasignaciones sucesivas, se denomina agrupamiento o clustering.

Agrupamiento o clustering
Agrupamiento o clustering: H(X) <> H(Y) y RH(X) = RH(Y) en reasignaciones sucesivas, se cumple que:

cualquier funcin de reasignacin que dependa nicamente del ndice dar lugar a agrupamiento. dara agrupamiento la funcin de reasignacin Rh(i) = ( i + c ) % m aunque c y m fuesen primos.

Rehashing. Prueba cuadrtica

El clustering se debe a que asignaciones sucesivas siguen la misma secuencia. Si se consigue que esa secuencia vare en cada reasignacin se evitara la formacin de cluster. Las tcnicas de prueba cuadrtica y doble direccin hash minimizan el agrupamiento.

Rehashing. Prueba cuadrtica.

Este mtodo es similar al de la prueba lineal. La diferencia consiste en que, en lugar de buscar en las posiciones con direcciones: dir_Hash, dir_Hash + 1, dir_Hash + 2, dir_Hash + 3, .... buscamos linealmente en las posiciones con direcciones: dir_Hash, dir_Hash + 1, dir_Hash + 4, dir_Hash + 9, ..., dir_Hash+i2 Si el nmero m de posiciones en la tabla T es un nmero primo y el factor de carga no excede del 50%, sabemos que siempre insertaremos el nuevo elemento X y que ninguna celda ser consultada dos veces durante un acceso.

Cdigo. Prueba Cuadrtica.

public static int pruebaCuadratica(int X, int[] A){ int m = A.length; int dirHash = X%m; if (A[dirHash] == X) return dirHash; else { int i = 1; int cont = 0; int dirReh = (dirHash + 1)%m; while ((A[dirReh] != X) && (A[dirReh] != 0) && (cont < m*10)) { i++; dirReh = (dirHash + (i*i))%m; cont++; } if (A[dirReh] == X) return dirReh; else return -1;

Rehasing. Doble direccin hash.

Consiste en que una vez detectada la colisin se debe generar otra direccin aplicando una funcin hash H2 a la direccin previamente obtenida. Entonces buscamos linealmente en las posiciones que se encuentran a una distancia H2(X), 2 H2(X), 3 H2(X), ... La funcin hash H2 que se aplique a las sucesivas direcciones puede ser o no ser la misma que originalmente se aplic a la clave. No existe una regla que permita decidir cul ser la mejor funcin a emplear en el clculo de las sucesivas direcciones. Pero una buena eleccin sera H2(X) = R (X%R), siendo R un nmero primo ms pequeo que el tamao del array. Y se obtienen unos resultados mejores cuando el tamao del array es un nmero primo.

Cdigo. Doble direccin Hash.

public static int dobleDireccionamiento(int X, int R, int[] A){ int m = A.length; int dirHash = X%m; if (A[dirHash] == X) return dirHash; else { int dirHash2 = R (X%R); int i = 1; int dirReh = (dirHash + dirHash2)%m; while ((A[dirReh] != X) && (A[dirReh] != 0) ) { i++; dirReh = (dirHash + i*dirHash2)%m; } if (A[dirReh] == X) return dirReh; else return -1; } }

Problemas de Rehasing
INSERCIN: Como se asume una tabla de tamao fijo, si el nmero de elementos aumenta ms all de ese tamao es imposible insertarlo sin que sea necesario asignar una tabla ms grande y recalcular los valores de asignacin de las claves de todos los elementos que ya se encuentran en la tabla utilizando una nueva funcin de asignacin. BORRADO: Es difcil eliminar un elemento. Por ejemplo, si el elemento r1 est en la posicin p, para aadir un elemento r2 cuya clave k2 queda asignada en p, ste debe ser insertado en la primera posicin libre de las siguientes: Rh(p), Rh(Rh(p)).. Si luego r1 es eliminado y la posicin p queda vaca, una bsqueda posterior del elemento r2 comenzar en la posicin H(k2) =p. Como esta posicin est ahora vaca, el proceso de bsqueda puede errneamente llevarnos a la conclusin de que el elemento r2 no se encuentra en la tabla. Solucin: marcar el elemento eliminado como 'eliminado' en vez de 'vaco', y continuar la bsqueda cuando se encuentra una posicin como 'eliminada'.

Tablas Hash Abiertas

Otro mtodo para resolver las colisiones consiste en mantener una lista encadenada de todos los elementos cuyas claves generan la misma posicin. Si la funcin hash genera valores entre 0 y (m - 1), declaramos un array de nodos de encabezamiento de tamao m, de manera que Tabla[i] apunta a la lista con todos los elementos cuyas claves generan posiciones en i. INSERCION?: Al buscar un elemento cuya funcin hash le hace corresponder la posicin i, se accede a la cabeza de la lista correspondiente a esa posicin, Tabla[i], y se recorre la lista que dicha posicin inicia. Si ste no se encuentra entonces se inserta al final de la lista. ELIMINACIN?: La eliminacin de un nodo de una tabla que ha sido construida mediante randomizacin y encadenamiento se reduce simplemente a eliminar un nodo de la lista encadenada. Un nodo eliminado no afecta a la eficiencia del algoritmo de bsqueda. El algoritmo contina como si el nodo nunca se hubiera insertado.

Tablas Hash Abiertas.

Estas listas pueden reorganizarse para maximizar la eficiencia de bsqueda, utilizando diferentes mtodos:
PROBABILIDAD. Consiste en insertar los elementos dentro de la lista en su punto apropiado. Esto significa que si pb es la probabilidad de que un elemento sea el argumento buscado, entonces el elemento debe insertarse entre los elementos r(i) y r(i+1), donde i es tal que P(i)>=pb>= P( i+1 ) MOVIMIENTO AL FRENTE: Cuando una bsqueda ha tenido xito, el elemento encontrado es retirado de su posicin actual en la lista y colocado en la cabeza de dicha lista. TRASPOSICIN: Cuando una bsqueda de un elemento ha tenido xito es intercambiado con el elemento que le precede inmediatamente, de manera que si es accedido muchas veces llegar a ocupar la primera posicin de la lista.

Complejidad Tablas Hash Abiertas

El nmero medio de pruebas, con encadenamiento, para una bsqueda con xito y para una bsqueda sin xito tiene los siguientes valores aproximados: S() = 1 + U() = e- +
VENTAJAS?: Es el mtodo ms eficiente debido al dinamismo propio de las listas. Cualquiera que sea el nmero de colisiones registradas en una posicin, siempre ser posible tratar una ms. DESVENTAJAS?: La desventaja principal es el espacio extra adicional que se requiere para la referencia a otros elementos. Sin embargo, la tabla inicial es generalmente pequea en esquemas que utilizan encadenamiento comparado con aquellos que utilizan reasignacin. Esto se debe a que el encadenamiento es menos catastrfico si la tabla llega a llenarse completamente, pues siempre es posible asignar ms nodos y aadirlos a varias listas.

Zona de desbordamiento
Se trata de mantener una zona reservada para aquellos elementos que llegan a colisionar, de manera que cuando se produzca una colisin el elemento se va a localizar en esta zona de desbordamiento. Al realizar la bsqueda y comprobar que la posicin est ocupada por otro elemento con el mismo valor de hashing, se seguir buscando a partir del inicio de la zona de desbordamiento de manera secuencial, hasta encontrar el elemento o llegar al final de dicha zona de desbordamiento.

Algoritmos de Ordenacin.

Ordenacin
La ordenacin de elementos segn un orden ascendente o descendente influye notablemente en la velocidad y simplicidad de los algoritmos que los manipulan posteriormente. En general, un conjunto de elementos se almacenan en forma ordenada con el fin de simplificar la recuperacin de informacin manualmente, o facilitar el acceso mecanizado a los datos de una manera ms eficiente. Los mtodos de ordenacin se suelen dividir en:

ordenamiento interno, si los elementos que han de ser ordenados estn en la Memoria Principal. ordenamiento externo, si los elementos que han de ser ordenados estn en un dispositivo de almacenamiento auxiliar.

Complejidad algoritmos de ordenacin

La complejidad de cualquier algoritmo estima el tiempo de ejecucin como una funcin del nmero de elementos a ser ordenados. Cada algoritmo estar compuesto de las siguientes operaciones:

Generalmente, la funcin de complejidad solo computa COMPARACIONES porque el nmero de las otras operaciones es como mucho constante del nmero de comparaciones.

COMPARACIONES que prueban si Ai < Aj Ai < B (donde B es una variable auxiliar) INTERCAMBIOS: permutar los contenidos de Ai y Aj Ai y B ASIGNACIONES de la forma B Ai, Aj B Aj Ai

Ordenacin por insercin

Tambin conocido como mtodo de la baraja. Consiste en tomar elemento a elemento e ir insertando cada elemento en su posicin correcta de manera que se mantiene el orden de los elementos ya ordenados. Es el mtodo habitual usado por los jugadores de cartas para ordenar: tomar carta por carta manteniendo la ordenacin.

Ordenacin por Insercin

Inicialmente se toma el primer elemento, a continuacin se toma el segundo y se inserta en la posicin adecuada para que ambos estn ordenados, se toma el tercero y se vuelve a insertar en la posicin adecuada para que los tres estn ordenados, y as sucesivamente.
1. 2.

Suponemos el primer elemento ordenado. Desde el segundo hasta el ltimo elemento, hacer:
1. 2. 3. 4.

suponer ordenados los (i 1) primeros elementos tomar el elemento i buscar su posicin correcta insertar dicho elemento, obteniendo i elementos ordenados

Cdigo Ordenacin por Insercin

public void OrdInsercion() { for (int i=1; i < A.length; i++)// Supone el primer elemento ordenado { int elem = A[i];// Elemento a ordenar int j = (i-1);// Posicin a comparar /*Si el elemento a comparar es mayor que el elemento a ordenar entones desplazo el elemento a comparar una posicin a la derecha para insertar el elemento a ordenar en la posicin correcta*/ while ((j >= 0) && (elem < A[j])) A[j+1] = A[j--]; /*Desplazo el elemento una posicin a la derecha y disminuyo en una unidad la Posicin a comparar*/ // Se inserta el elemento a ordenar en su posicin correcta A[j+1] = elem; }

Complejidad Ordenacin por Insercin

CASO MEJOR: Cuando el array est ordenado. Entonces slo se hace una comparacin en cada paso. Ej. 15 20 45 60 n=4 En general, para n elementos se hacen (n-1) comparaciones. Por tanto, complejidad O(n).
Pasada N de Intercambios N Comparacion es

1 2 3

0 0 0

1 1 1

Complejidad Ordenacin por Insercin

CASO PEOR: Cuando el array est ordenado inversamente. Ej. 86 52 45 20 n=4
52 86 45 20 45 52 86 20 20 45 52 86
Pasada N de Intercambios N Comparacion es

1 2 3

1 2 3

1 2 3

En general, para n elementos se realizan (n-1) intercambios y (n-1) comparaciones. Por tanto, O(n2).

Complejidad Ordenacin por Insercin

CASO MEDIO: Los elementos aparecen de forma aleatoria. Se puede calcular como la suma de las comparaciones mnimas y mximas dividida entre dos:
((n-1) + n(n-1)/2)/2 = (n2 + (n-2))/4 , por tanto complejida O(n2).

Insercin Binaria.
public void OrdInsercionBin() { for (int i=1; i < A.length; i++) { int elem = A[i]; int bajo = 0; int alto = (i-1); while (bajo <= alto)//Se busca la posicin donde se debe almacenar el elemento a ordenar { int medio = (alto + bajo)/2; if (elem < A[medio]) alto = medio -1; else bajo = medio + 1; } for (int j = (i-1); j >= bajo; j--)//Se desplazan todos los elementos mayores que el elemento a ordenar una posicion a la derecha A[j+1] = A[j]; A[bajo] = elem; }

Complejidad Insercin Binaria

Con la bsqueda binaria se reduce el nmero de comparaciones desde O(n2) hasta un O(n log n). Sin embargo, el nmero de sustituciones requiere un tiempo de ejecucin de O(n2). Por lo tanto, el orden de complejidad no cambia, adems la ordenacin por insercin se usa normalmente slo cuando n es pequeo, y en este caso la bsqueda lineal es igual de eficiente que la bsqueda binaria.

Ordenacin por Seleccin.

Este mtodo se basa en que cada vez que se mueve un elemento, se lleva a su posicin correcta. Se comienza examinando todos los elementos, se localiza el ms pequeo y se sita en la primera posicin. A continuacin, se localiza el menor de los restantes y se sita en la segunda posicin. Se procede de manera similar sucesivamente hasta que quedan dos elementos. Entonces se localiza el menor y se sita en la penltima posicin y el ltimo elemento, que ser el mayor de todos, ya queda automticamente colocado en su posicin correcta. Para i desde la primera posicin hasta la penltima
localizar menor desde i hasta el final intercambiar ambos elementos

Cdigo Ordenacin por Seleccin

public void OrdSeleccion() { //Para todos los elementos desde el primero hasta el penultimo for (int i=0; i < (A.length-1); i++) { int menor = i; /*Se localiza el elemento menor desde la posicin desde la cual se est ordenando hasta el ltimo elemento*/ for (int j=(i+1);j < A.length; j++) if (A[j] < A[menor]) menor = j; /*Si el elemento a ordenar es distinto del de la posicin que se est ordenando se intercambian los elementos*/ if (menor != i) intercambiar(i,menor);//intercambia los elementos de esas posiciones }

Complejidad Ordenacin por Seleccin

El tiempo de ejecucin de dicho algoritmo viene determinado por el nmero de comparaciones, las cuales son independientes del orden original de los elementos, el tiempo de ejecucin es O(n2).
f(n) = (n-1) + (n-2) + + 2 + 1 = n(n-1)/2

O(n2). El nmero de intercambios es O(n). Por tanto complejidad O(n2).

Desventajas Ordenacin por Seleccin.

Muy lenta con arrays grandes. No detecta si el array est todo ni parcialmente ordenado.

Ordenacin por Intercambio o Burbuja

Se basa en el principio de comparar e intercambiar pares de elementos adyacentes hasta que todos estn ordenados. Desde el primer elemento hasta el penltimo no ordenado
comparar cada elemento con su sucesor intercambiar si no estn en orden

Cdigo Ordenacin por Burbuja

public void OrdBurbuja(){ for (int pasada=0; pasada < A.length-1; pasada++) for (int j=0; j < (A.length-pasada-1); j++) if (A[j] > A[j+1]) intercambiar(j,j+1); }

Si tenemos en cuenta que tras una pasada puede suceder que ya estn todos los elementos ordenados, en este caso no sera necesario seguir realizando comparaciones.

Mejora Ordenacin Burbuja

public void OrdBurbuja2() { boolean noOrdenados = true; int pasada = 0; while ((noOrdenados) && (pasada < A.length -1)) { noOrdenados = false; for (int j=0; j < (A.length-pasada-1); j++) if (A[j] > A[j+1]) { intercambiar(j,j+1); noOrdenados = true; } pasada ++; } }

Complejidad Ordenacin Burbuja

El tiempo de ejecucin de dicho algoritmo viene determinado por el nmero de comparaciones, en el peor de los casos O(n2). COMPARACIONES: (n-1) + (n-2) + +
3 + 2 + 1 = n(n-1)/2 + 2 + 1 = n(n-1)/2 O(n2) O(n2)

INTERCAMBIOS: (n-1) + (n-2) + + 3

Ventajas y Desventajas Ordenacin Burbuja

Su principal ventaja es la simplicidad del algoritmo. El problema de este algoritmo es que solo compara los elementos adyacentes del array. Si el algoritmo comparase primero elementos separados por un amplio intervalo y despus se centrase progresivamente en intervalos ms pequeos, el proceso sera ms eficaz. Esto llevo al desarrollo de ordenacin Shell y QuickSort.

Ordenacin Shell
Es una mejora de la ordenacin por insercin (colocar cada elemento en su posicin correcta, moviendo todos los elementos mayores que l, una posicin a la derecha), que se utiliza cuando el nmero de datos a ordenar es grande. Para ordenar una secuencia de elementos se procede as: se selecciona una distancia inicial y se ordenan todos los elementos de acuerdo a esa distancia, es decir, cada elemento separado de otro a distancia estar ordenado con respecto a l. Se disminuye esa distancia progresivamente, hasta que se tenga distancia 1 y todos los elementos estn ordenados.

Ejemplo Ordenacin Shell

Posicin Original 0 4 1 14 14 14 14 6 2 3 4 18 18 6 5 17 17 17 32 32 21 6 26 26 26 18 21 21 26 7 8

21 32 21 32

40 6 40 6 18 40 18 26 40 26 32 40

Distancia 4 4 Distancia 2 4
Ordenacin Distancia 1 4 por Inserccin

21 32 6 6 17 21 18 6 17 18 18

Final

14 17

Cdigo Ordenacin Shell

public void OrdShell () { int intervalo = A.length /2; /* distancia, los elementos estar ordenados a una distancia igual a intervalo.*/ while (intervalo > 0) //Se ordenan hasta que la distancia sea igual a 1 { for (int i = intervalo; i < A.length; i++) { int elem=A[i]; int j = i - intervalo; // Posicion del elemento a comparar while (( j > -1) && (elem<A[j])) { A[j+intervalo]=A[j]; j -= intervalo; } A[j+intervalo]=elem; } intervalo = intervalo /2; } }

Complejidad de Shell
No es fcil de calcular. O(n3/2). Si se divide la distancia por 2.2 optiene una complejidad de O(n5/4). El tiempo de ejecucin depende de la secuencia de incrementos que se elige. El rendimiento de la ordenacin Shell es bastante aceptable en la prctica, an para n grande. Su simplicidad lo hace adecuado para clasificar entradas moderadamente grandes.

Ordenacin por mezcla (mergesort)

Para ordenar una secuencia de elementos S, un procedimiento podra consistir en dividir S en dos subsecuencias disjuntas, ordenarlas de forma independiente y unir los resultados de manera que se genere la secuencia final ordenada. Dentro de esta filosofa es posible hacer una distincin de los algoritmos en dos categoras:
Algoritmos de fcil divisin y difcil unin, el MERGESORT. Algoritmos de difcil divisin y fcil unin, el QUICKSORT.

Ordenacin por mezcla (mergesort)

El MERGESORT consiste en :
Dividir los elementos en dos secuencias de la misma longitud aproximadamente. Ordenar de forma independiente cada subsecuencia. Mezclar las dos secuencias ordenadas para producir la secuencia final ordenada.

Cdigo MergeSort
public void mergeSort (int [] A, int bajo, int alto){ if (bajo < alto) //Si hay ms de un elemento { int medio = (alto + bajo)/2; mergeSort (A, bajo, medio); mergeSort (A, medio+1, alto); //Procedimiento que mezcla el resultado de las dos llamadas anteriores merge (A, bajo, medio+1, alto); } }

Cdigo Mezcla de MergeSort.

El proceso de mezcla es el siguiente:
Repetir mientras haya elementos en una de las dos secuencias: Seleccionar el menor de los elementos de las subsecuencias y aadirlo a la secuencia final ordenada. Eliminar el elemento seleccionado de la secuencia a la que pertenece. Copiar en la secuencia final los elementos de la subsecuencia en la que an quedan elementos.

Cdigo Mezcla de MergeSort.

public void merge (int [] A, int bajo, int bajo_2, int alto) { int i = bajo; //Variable de primer elemento de la primera subsecuencia int finbajo = bajo_2 -1; //Variable del ltimo elemento de la primera subsecuencia int j = bajo_2; //Variable del primer elemento de la segunda subsecuencia int k = bajo; /* Temp es un array ya definido*/ while (( i <= finbajo) && (j<= alto)) { if (A[i] <= A[j]) Temp[k++] = A[i++]; else Temp[k++] = A[j++]; } while (i <= finbajo) //Si se agotaron todos los elementos de la segunda subsecuencia Temp[k++] = A[i++]; while (j <= alto) //Si se agotaron los de la primera subsecuencia Temp[k++] = A[j++]; //Paso todos los elementos del Temporal al array for (i = bajo; i <= alto; i++) A[i] = Temp[i]; }

Complejidad Mezcla de MergeSort.

Teniendo en cuenta que la entrada consiste en el total de elementos n y que cada comparacin asigna un elemento a Temp. El nmero de comparaciones es (n-1) y el nmero de asignaciones es n. Por lo tanto, el algoritmo de mezcla se ejecuta en un tiempo lineal O(n).

Complejidad MergeSort
El anlisis de eficiencia de la ordenacin por mezcla da lugar a una ecuacin recurrente para el tiempo de ejecucin. Suponemos n potencia de 2, n = 2K Para N = 1, Tiempo constante. Para N > 1, El tiempo de ordenacin para n nmeros es igual al tiempo para 2 ordenaciones recursivas de tamao n/2 + el tiempo para mezclar (que es lineal). Por tanto, T(n) = 2 T(n/2) + n
Tiempo de Mezclar Tiempo de Ordenacin Log2 n = k

Complejidad MergeSort
Para resolver la ecuacin se divide por n. T(n) / n = (2 (T (n/2)) / n) + (n/n) T(n) / n = T(n/2) / (n/2) + 1 Esta ecuacin es vlida para cualquier potencia de 2, as que se puede escribir: T(n/2) / (n/2) = (T(n/4) / (n/4)) + 1 T(n/4) / (n/4) = (T(n/8) / (n/8)) + 1 As sucesivamente, hasta T(2) = (T(1) / 1) + 1

Complejidad MergeSort
Se suman todas las ecuaciones anteriores, como todos los trminos se anulan, se obtiene el siguiente resultado:
T(n) / n = (T(1) / 1) + k, siendo K el nmero de ecuaciones que tenemos, es decir, el nmero de divisiones a la mitad que realizamos, por tanto k = log2n Para resolver la ecuacin se dividi entre n, por tanto ahora multiplicamos por n. T(n) = n + n log n. Por tanto la complejidad del algoritmo MergeSort es de O (n log n)

Ordenacin Rpida (QuickSort)

En la ordenacin rpida, la secuencia inicial de elementos se divide en dos subsecuencias de diferente tamao. La obtencin de las dos subsecuencias es el proceso que acarrea ms tiempo mientras que la combinacin de las subsecuencias ordenadas para obtener la secuencia final consume muy poco tiempo. Para dividir en dos la secuencia de elementos, se selecciona un elemento sobre el cual efectuar la divisin, el PIVOTE. Se dividen los elementos en dos grupos, los elementos menores que el pivote y aquellos mayores o igual al pivote.

Ordenacin QuickSort.
La eleccin del elemento Pivote se puede seleccionar de diferentes formas:
El mayor de los dos primeros elementos distintos encontrados. El primer elemento. El ltimo elemento. El elemento medio. Un elemento aleatorio. Mediana de tres elementos (El primer elemento, el elemento del medio y el ltimo elemento).

Pasos a seguir QuickSort.

El mtodo de ordenacin rpida se basa en ordenar los elementos comprendidos entre Ai y Aj conforme a las siguientes cinco etapas:
1. 2. 3. 4.

Si desde Ai a Aj hay al menos dos elementos distintos entonces comenzar la aplicacin del algoritmo. Seleccionar el PIVOTE como el elemento mayor de los dos primeros elementos distintos encontrados. Insertar PIVOTE en la ltima posicin. Permutar los elementos desde Ai hasta Aj de modo que, para algn i <= k <= j :

Ai, ..., Ak-1 < PIVOTE Ak, ..., Aj >= PIVOTE Es decir, en las (k-1) primeras posiciones queden los elementos menores que pivote, mientras que en la posicin k hacia delante queden los elementos mayores o iguales que el pivote.

5.

Invocar a:

QUICKSORT desde i hasta (k 1) QUICKSORT desde k hasta j

Paso 2: Eleccin del Pivote

Para la eleccin del pivote se puede utilizar la siguiente funcin que localiza el elemento mayor de los dos primeros elementos distintos existentes entre el i y el j.
int buscaPivote (int i, int j) { int primer = A[i]; int k = i + 1; while (k <= j) { if (A[k] > primer) return k; else if (A[k] < primer) return i; else k++; } //Si llega al final del array y todos los elementos son iguales, o si slo hay un elemento return -1;

Paso 4: Permutacin de elementos

Para el paso 4 de permutacin de los elementos se utilizan dos cursores:
D : para mover a la derecha mientras el elemento sea menor que el pivote. I : para mover a la izquierda mientras el elemento sea mayor o igual que el pivote

de acuerdo a tres fases :

AD < PIVOTE y AI >= PIVOTE

CAMBIO : Si D < I se intercambian AD y AI, con lo cual probablemente: EXPLORACIN: Mover

COMPROBACIN: Si D > I hemos acabado con xito la reordenacin.

D hacia la derecha sobre cualquier elemento MENOR que el pivote y I hacia la izquierda sobre cualquier elemento MAYOR o IGUAL que el pivote.

Cdigo, paso 4.
int particion (int i, int j, int pivote) { int derecha = i; int izquierda = j-1; while (derecha <= izquierda) { intercambiar(derecha,izquierda); while (A[derecha] < pivote) derecha++; while (A[izquierda] >= pivote) izquierda--; } return derecha; }

Cdigo QuickSort
void quickSort (int [] A, int i, int j) { int indicePivote = buscaPivote(i, j); if (indicePivote != -1) { int pivote = A[indicePivote]; intercambiar(indicePivote,j); int k = particion(i,j,pivote); quickSort(A, i, k-1); quickSort(A, k,j); } }

Complejidad QuickSort.
Caso Mejor: Cuando el pivote, divide al conjunto en dos subconjuntos de igual tamao. En este caso hay dos llamadas con un tamao de la mitad de los elementos, y una sobrecarga adicional lineal, igual que en MergeSort. En consecuencia el tiempo de ejecucin es O(n log n).

Complejidad QuickSort.
Caso Peor: Se podra esperar que los subconjuntos de tamao muy distinto proporcionen resultados malos. Supongamos que en cada paso de recursin slo hay un elemento menor a pivote. En tal caso el subconjunto I (elementos menores que pivote) ser uno y el subconjunto D (elementos mayores o igual a pivote) sern todos los elementos menos uno. El tiempo de ordenar 1 elemento es slo 1 unidad, pero cuando n > 1. T(N) = T(N-1) + N T(N-1) = T(N-2) + (N-1) T(N-2) = T(N-3) + (N-2) . T(2) = T(1) + 2 T(N) = T(1) + 2 + 3 + 4 + + N = N (N+1) /2 , O(n2).

Complejidad QuickSort.
Caso Medio: Complejidad O(n log n).