TRABAJO DE ESTRUCTURAS DE DATOS

METODOS DE ORDENACION INTERNOS:

Se aplica tpicamente sobre vectores.
Los elementos a ordenar estn todos en memoria.
Los intercambios, desplazamientos, etc., pueden aplicarse sobre
cualquiera
de
los
elementos del vector.
A continuacin algunos mtodos de ordenacin:

HEAP SORT
PSEUDOCODIGO

HEAP SORT(ENTERO * vector, ENTERO num) {

//Ordena un vector de elementos
INICIO
ENTERO i,j;
ENTERO ultimo
num-1;
ENTERO aux; //Variable auxiliar para intercambio
PARA(i

(ultimo-1)/ 2; i>=0; i--) // ser ordena el montculo

CRIBA(vector, i, ultimo);
FIN_PARA
// Ordenacin del vector
PARA(i ultimo; i>=1; i--)
aux = vector[0];
vector[0] = vector[i];
vector[i] = aux;
criba(vector, 0, i-1);
FIN_PARA
FIN

FUNCIONAMIENTO
Este mtodo es una variante del mtodo por seleccin, donde la
bsqueda del elemento mximo de un arreglo se realiza mediante
tcnicas basadas en la construccin de un montculo.
Puede ser un montculo ascendente o descendente.
VENTAJAS
- Su desempeo es en promedio tan bueno como el Quicksort y se
comporta mejor que este ltimo en los peores casos.
DESVENTAJAS
- Aunque el Heapsort tiene un mejor desempeo general que
cualquier otro mtodo presentado de clasificacin interna, es
bastante complejo de programar.
COMPLEJIDAD
MEJOR CASO:
Es de complejidad O(n)
PEOR CASO:
Es de complejidad O(nlogn)
EJEMPLO
Veamos grficamente un ejemplo de este tipo de rbol:

Al enumerar los nodos por niveles, de izquierda a derecha (como se

aprecia en la figura), no es necesario usar punteros para almacenar el
rbol.
En efecto, se puede usar un arreglo A[1..n], donde los hijos de A[i] son
A[2*i] y A[2*i+1]. As, la condicin del Heap se puede reformular:
A[i] > A[2*i]
A[i] > A[2*i+1]
Luego un vector con las llaves quedara de la siguiente forma:

73 - 50 - 36 - 21 - 46 - 27 - 9 - 18 - 10 - 30

BIN SORT
PSEUDOCODIGO

OrdenacionBinsort(vector, n)
inicio
CrearUrnas(Urnas);
{
//Distribucin de registros en sus correspondientes urnas
}
desde j = 1 hasta n hacer
AadirEnUrna(Urnas[vector[j].clave], vector[j]);
fin_desde
{
//Concatena las listas que representan a las urnas
desde Urnai hasta Urnam
}
i = 1;
{
//bsqueda de primera urna no vaca
}
mientras EstaVacia(Urnas[i]) hacer
i = i+1
fin_mientras
desde j = i+l a m hacer
EnlazarUrna(Urnas[i], Urnas[j]);
fin_desde
{
//Se recorre la lista-urna resultante de la concatenacin}
j = 1;
dir = <frente Urnas[i]>;
mientras dir <> nulo hacer
vector[j] = <registro apuntado por dir>;
j = j+i;
dir = Sgte(dir)
fin_mientras
fin
FUNCIONAMIENTO
Este mtodo, tambin llamado clasificacin por urnas, persigue
conseguir funciones de tiempo de ejecucin menores de O(n log n),
para ordenar una secuencia de n elementos siempre que se conozca
algo acerca del tipo de las claves por las que se estn ordenando.

VENTAJAS
El ordenamiento es razonablemente eficiente si el nmero de
dgitos en las llaves no es demasiado grande.
Si las mquinas tienen la ventaja de ordenar los dgitos (sobre todo
si estn en binario) lo ejecutaran con mucho mayor rapidez de lo que
ejecutan una comparacin de dos llaves completas.
DESVENTAJAS

Se requiere conocer la cantidad de dgitos del valor mximo (para

saber cuando el mtodo ya acomodo todos los elementos).

COMPLEJIDAD
Debido a que el ciclo for (k = 1; k <= m; k++) externo se recorre m veces
(una para cada dgito) y el ciclo interior n veces (una para cada elemento en
el archivo) el ordenamiento es de aproximadamente (m*n).
Si las llaves son complejas (es decir, si casi cada nmero que puede ser
una llave lo es en realidad) m se aproxima a log n, por lo que (m*n) se
aproxima a (n log n).
Si la cantidad de dgitos es grande, en ocasiones es ms eficiente ordenar
el archivo aplicando primero el ordenamiento de raz a los dgitos ms
significativos y despus utilizando insercin directa sobre el archivo
ordenado.

EJEMPLO
Suponer que se han de ordenar estas fichas identificadas por tres
dgitos:
345, 721, 425, 572, 836, 467, 672,194, 365, 236, 891, 746, 431, 834,
247, 529, 216, 389
Atendiendo al dgito de menor peso (unidades) las fichas se
distribuyen en montones del 0 al 9;

Recogiendo los montones en orden, la secuencia de fichas queda:

721, 891, 431, 572, 672, 194, 834, 345, 425, 365, 836, 236, 746, 216,
467, 247, 529, 389
De esta secuencia podemos decir que est ordenada respecto al
dgito de menor peso, respecto a las unidades. Pues bien, ahora de
nuevo se distribuye la secuencia de fichas en montones respecto al
segundo dgito:

Recogiendo de nuevo los montones en orden, la secuencia de fichas

queda:

216, 721, 425, 529, 431, 834, 836, 236, 345, 746, 247, 365, 467, 572,
672, 389, 891, 194
En este momento esta secuencia de fichas ya estn ordenadas
respecto a los dos ltimos dgitos, es decir, respecto a las decenas.
Por ltimo, se distribuye las fichas en montones respecto al tercer
dgito:

Recogiendo de nuevo los montones en orden, la secuencia de fichas

queda ya ordenada:
194, 216, 236, 247, 345, 365, 389, 425, 431, 467, 529, 572, 672, 121,
746, 834, 836, 891

RADIX SORT
PSEUDOCODIGO

OrdenacionRadixsort(vector, n)
Inicio
< clculo el nmero mximo de dgitos: ndig >
peso = 1 { permite obtener los dgitos de menor a mayor peso}
desde i = 1 hasta ndig hacer
CrearUrnas(Urnas);
desde j = 1 hasta n hacer
d = (vector[j] / peso) modulo 10;
AadirEnUma(Urnas[d], vector[j]);
fin_desde
< bsqueda de primera urna no vaca: j >
desde r = j+1 hasta M hace { M: nmero de urnas }
EnlazarUma(Urnas[r], Urnas[j]);
fin_desde
{Se recorre la lsta-urna resultante de la concatenacin}
r = 1;
dir = frente(Urna[j]);
mientras dir <> nulo hacer
vector[r] = dir.registro;
r = r+1;
dir = siguiente(dir)
end
peso = peso * 10;
fin_desde
fin_ordenacion
FUNCIONAMIENTO

Convertir el arreglo en un heap

Construir un arreglo ordenado de atrs hacia adelante (mayor a

menor) repitiendo los siguientes pasos:

Sacar el valor mximo en el heap (el de la posicin 1)
Poner ese valor en el arreglo ordenado
Reconstruir el heap con un elemento menos
Utilizar el mismo arreglo para el heap y el arreglo ordenado
VENTAJAS
DESVENTAJAS
COMPLEJIDAD
MEJOR CASO:
Es de O(nlogn)
PEOR CASO:
CASO MEDIO:
EJEMPLO
0, 1, 81, 64, 4, 25, 36, 16, 9, 49
PRIMERA FASE
Cubeta
0
1
2
3
4
5
6
7
8
9
Cubeta
0
1
2
3
4
5
6
7
8
9

Contenido
Contenido
0
1,81
64,4
25
36,16
9,49
0,1,4,9
16
25
36
49
64
81

SEGUNDA FASE

QUICKSORT
PSEUDOCODIGO
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 */

}
FUNCIONAMIENTO
Es un alGgoritmo recursivo (de tipo divide y vencers). Es decir,
divide
el arreglo en dos partes y las ordena independientemente.
VENTAJAS
Emplea NLog(N) operacionales en promedio para ordenar N
elementos.
-

Su bucle interno extremadamente corto.

DESVENTAJAS
-

Es recursivo y su implementacin no recursiva es complicada.

El desempeo es N2 en su peor caso.

COMPLEJIDAD
EN LOS CASOS MEJOR Y MEDIO:
Es de complejidad O (nlogn)
PEOR CASO:
Es de complejidad O (n2)
EJEMPLO

METODOS DE ORDENACION EXTERNA:

Ordenacin externa, sobre ficheros.
Los elementos a ordenar estn todos en disco.
Los intercambios, desplazamientos, etc., NO pueden aplicarse sobre
cualquiera de
los elementos del fichero (o al menos no de forma tan sencilla).
El nmero de registros a ordenar puede ser muy grande.

Mezcla directa
FUNCIONAMIENTO
La idea central de este algoritmo consiste en la realizacin sucesiva
de una particin y una fusin que produce secuencias ordenadas de
longitud cada vez mayor. En la primera pasada la participacin es de
longitud 1 y la fusin o mezcla produce secuencias ordenadas de
longitud 4. Este proceso se repite hasta que la longitud de la
secuencia para la particin sea mayor o igual que la longitud de la
secuencia para la particin sea mayor o igual que el nmero de
elementos del archivo original.
VENTAJA
Buena complejidad
DESVENTAJAS
Consume mucha memoria: Hecho comn a todos los algoritmos de
ordenacin externa.
1. Particionar en 2 ficheros de salida
2. Fusionar con secuencias ordenadas cada vez mayores
Ejemplo:
F:
P1:
P2:

7
7
6

6
4
2

4
1
9

2
3
2

F:

P1:
P2:
F:
P1:
P2:

6
2
2
2
1

7
4
4
4
2

1
2
6
6
3

9
3
7
7
9

F:
P1:
P2:

Mezcla equilibrada
1. Particin por las secuencias ordenadas de mxima longitud.
2. Fusin
Ejemplo:

F:
P1:
P2:

7
7
6

6
4
2

4
1
3

2
9

1
2

F:
P1:
P2:

6
6
2

7
7
4

2
1
2

4
9
3

F:
P1:
P2:

2
2
1

4
4
2

6
6
3

7
7
9

F:
P1:
P2:

Mezcla Natural
VENTAJAS
Mejora la complejidad de la Mezcla Directa para vectores inicialmente
ordenados
Se comporta mejor que Mezcla Directa al aprovechar la fusin de
tramos.
COMPLEJIDAD DE MEZCLA NATURAL:
O(2n E[log2t+1])=O(nlog2t)

Caso peor: Vector inversamente ordenado Inicialmente n tramos>igual

que mezcla directa
Caso mejor: Vector ordenado: Inicialmente tenemos un tramo = O(n)