Trabajo de Investigacin - Ordenamiento

CURSO

: Algoritmos y Estructura De
Datos II

DOCENTE

: Manuel Malpica Rodrguez

ALUMNOS

: CUEVA LPEZ, Milton

: MEJA ROJAS, Alexander

CICLO

: III

INDICE

INDICE.......................................................................................................... 2
INTRODUCCION............................................................................................ 3
OBJETIVOS.................................................................................................... 4
ORDENAMIENTO........................................................................................... 5
1.

ORDENAMIENTO POR SHELL SHORT.......................................................6

2.

ORDENAMIENTO POR QUICK SHORT......................................................9

3.

ORDENAMIENTO POR MERGE SHORT...................................................13

4.

ORDENAMIENTO POR HEAP SHORT...................................................17

CONCLUSIONES.......................................................................................... 21
REFERENCIAS............................................................................................. 22

INTRODUCCIN
Los mtodos de ordenamiento nos permiten, como su nombre lo dice,
ordenar. En este caso, nos servirn para ordenar vectores con valores
asignados aleatoriamente. Los cules sern necesarios para luego buscar
datos de una manera mucho ms rpida y eficiente. Nos centraremos en
los mtodos (Shell short, Merge short, Quick short y Heap short).
Cada mtodo de ordenamiento contara con una animacin para el mejor
entendimiento de los mismos, adems de su codificacin en java.

OBJETIVOS

Describir cada uno de los mtodos de ordenamiento y ver cmo

interactan cada uno de ellos
Determinar que mtodos de ordenamientos son ms eficientes.

ORDENAMIENTO
Es una suma de elementos dispuestos de una determinada manera
para lograr la consecucin de un fin determinado.

MTOS DE ORDENAMIENTO
Es un algoritmo que pone elementos de una lista o un vector en una
secuencia dada por una relacin de orden, es decir; el resultado de la salida
puede ser una permutacin o un reordenamiento de la entrada que satisfaga
la relacin de orden dada. Las relaciones de orden que ms se utilizan son el
de orden numrico y el orden Lexicogrfico.
Clasificacin
Ordenamiento Interno
Estos trabajan en memoria principal y sus implementaciones son muy
variadas, de manera que la eleccin del algoritmo adecuado debe realizarse
con criterios de eficiencia (tiempo y ejecucin) y en funcin de la memoria
disponible. Dividiremos los mtodos en dos grandes grupos:
1. Directos
Burbuja
Seleccin
Insercin

2. Logartmicos
Shell short
Merge short
Heap short
Quick short
Radix

Ordenamiento Externo
La ordenacin de archivos se lleva a cabo cuando el volumen de los datos a
tratar es demasiado grande y los mismos no caben en la memoria principal de
la computadora.
Los dos mtodos de ordenamiento ms importantes son los basados en la
mezcla directa y en la mezcla equilibrada.

1. ORDENAMIENTO POR SHELL SHORT

Shell Sort lleva este nombre en honor a su inventor, Donald Shell, que
lo public en 1959. La idea bsica de este mtodo es distribuir el
arreglo de manera que se genere una matriz de valores donde cada
elemento es comparado de manera adyacente empleando un

mecanismo de insercin directa simple, dicho rango que genera grupos

de manera matricial que es reducido gradualmente hasta estabilizarse
en un valor uniforme de 1.
En el mtodo de ordenacin por insercin directa es empleado en cada
sub grupo de manera que cada elemento se compara para su ubicacin
correcta en el arreglo con los elementos que se encuentran en su parte
izquierda. Si el elemento a insertar es ms pequeo que el grupo de
elementos que se encuentran a su izquierda, ser necesario efectuar
varias comparaciones antes de su ubicacin. Shell propone que las
comparaciones entre elementos se efecten con saltos de mayor
tamao, pero con incrementos decrecientes; as, los elementos
quedaran ordenados ms rpidamente.

Consideremos el siguiente ejemplo, tenemos una lista de nmeros como:

13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10

Paso 1:

Si comenzamos con un tamao de paso de 5,

podramos visualizar esto dividiendo la lista de nmeros en una
tabla con 5 columnas. Esto quedara as:
13 14 94 33 82
39
10

25 59 94 65 23

45 27 73 25

Paso 2: Entonces ordenamos cada columna, lo que nos da.

10 14 73 25 23
82
45

Paso 3:

13 27 94 33 39

25 59 94 65

Lo leemos de nuevo como una nica lista de nmeros.

10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45

Paso 4:

El 10 que estaba en el extremo final, se ha movido hasta el

extremo inicial. Esta lista es entonces de nuevo ordenada usando un
ordenamiento con un espacio de 3 posiciones, y despus un
ordenamiento con un espacio de 1 posicin (ordenamiento por insercin
simple).
10 14 73
65 82

Paso 5:
10 14 13
94 82

25 23 13

27 94 33

39 25 59

94

39 65 73

45

45
Generando.
25 23 33

27 25 59

94

Paso 5: Finalmente.
10 14 13 25 23 33 27 25 59 39 65 73 45 94 82 94

10 13 14 23 25 25 27 33 39 45 59 65 73 82 94 94

FUNCIONAMIENTO:

Pseudocdigo:

Cdigo java:

package shellsort;
package shellsort;
public class ShellSort {
public static void ordenar(long[] numeros) {
int salto, i;
long aux;
boolean cambios;
for (salto = numeros.length / 2; salto != 0; salto /= 2) {
cambios = true;
while (cambios) {
cambios = false;
for (i = salto; i < numeros.length; i++)
if (numeros[i - salto] > numeros[i]) {
aux = numeros[i];
numeros[i] = numeros[i - salto];
numeros[i - salto] = aux;
cambios = true;
}
}
}
}
}

Problema: Ordenar un vector de n elementos.

package shellsort;
import java.util.Random;
import java.util.Scanner;
public class PruebaShellSort {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Nmero de elementos");
int n = sc.nextInt();
long[] v = new long[n];
generarV(v);
mostrarV(v);
ShellSort(v);
}
private static void ShellSort(long[] v) {
System.out.println("Vector ordenado");
long[] numeros = v;
shellsort.ShellSort.ordenar(numeros);
mostrarV(v);
}
private static void mostrarV(long[] v) {
System.out.println();

for (int i = 0; i < v.length; i++) {

System.out.println(v[i]);
}
System.out.println();
}
private static void generarV(long[] v) {
Random r = new Random();
for (int i = 0; i < v.length; i++) {
v[i] = r.nextInt(10);
}
}
}

2. ORDENAMIENTO POR QUICK SHORT

Es un algoritmo relativamente eficiente y representa una mejora
sustancial al mtodo de intercambio directo.
El algoritmo es el siguiente:
1. Elegir un elemento de la lista de elementos a ordenar (pivote).
2. Resituar los dems elementos de la lista a cada lado del pivote, de
manera que a un lado queden todos los menores que l, y al otro los
mayores. Los elementos iguales al pivote pueden ser colocados tanto a
su derecha como a su izquierda, dependiendo de la implementacin
deseada. En este momento, el pivote ocupa exactamente el lugar que
le corresponder en la lista ordenada.
3. La lista queda separada en dos sub-listas, una formada por los
elementos a la izquierda del pivote, y otra por los elementos a su
derecha.
4. Repetir este proceso de forma recursiva para cada sub-lista mientras
stas contengan ms de un elemento. Una vez terminado este proceso
todos los elementos estarn ordenados.
Como se puede suponer, la eficiencia del algoritmo depende de la
posicin en la que termine el pivote elegido. En el mejor caso, el pivote
termina en el centro de la lista, dividindola en dos sublistas de igual
tamao. En este caso, el orden de complejidad del algoritmo es O(n log
n).
En el peor caso, el pivote termina en un extremo de la lista. El orden de
complejidad del algoritmo es entonces de O(n). El peor caso
depender de la implementacin del algoritmo, aunque habitualmente
ocurre en listas que se encuentran ordenadas, o casi ordenadas. Pero
principalmente depende del pivote, por ejemplo el algoritmo
implementado toma como pivote siempre el primer elemento del
arreglo, y el arreglo que le pasamos est ordenado, siempre va a
generar a su izquierda un arreglo vaco, lo que es ineficiente.

En el siguiente ejemplo se marcan el pivote y los ndices i y j con las

letras p, i y j respectivamente.

Ejemplo:
5-3-7-6-2-14

Paso 1: El elemento pivote ser el 4:

5-3-7-6-2-14
p
Paso 2: Comparamos con el 5 por la izquierda y el 1 por la derecha.
5-3-7-6-2-14
i

Paso 3: 5 es mayor que 4 y 1 es menor. Intercambiamos:

1-3-7-6-2-54
i

Paso 4: Avanzamos por la izquierda y la derecha:

1-3-7-6-2-54
i

Paso 5: 3 es menor que 4: avanzamos por la izquierda. 2 es menor que

4: nos mantenemos ah.
1-3-7-6-2-54
i

Paso 5: 7 es mayor que 4 y 2 es menor: intercambiamos.

1-3-2-6-7-5-4
i

Paso 6: Avanzamos por ambos lados:

1-3-2-6-7-54
iyj

Paso 7: En este momento termina el ciclo principal, porque los ndices

se cruzaron. Ahora intercambiamos lista[i] con lista[sup].
1-3-2-4-7-56
p

Paso 8: Aplicamos recursivamente a la sub-lista de la izquierda (ndices

0 - 2). Tenemos lo siguiente:
1-3-2
Paso 9: 1 es menor que 2: avanzamos por la izquierda. 3 es mayor:
avanzamos por la derecha. Como se intercambiaron los ndices termina
el ciclo. Se intercambia lista[i] con lista[sup]:
1-2-3
Paso 10: El mismo procedimiento se aplicar a la otra sub-lista. Al
finalizar y unir todas las sub-listas queda la lista inicial ordenada en
forma ascendente.
1-2-3-4-5-6-7

FUNCIONAMIENTO:

DIAGRAMA DE FLUJO:
CDIGO JAVA:
package quicksort;
public class QuickSort {
public void ordenar(int[] arreglo, int inicio, int fin) {
int i = inicio;
int f = fin;
int aux;
int pivote = arreglo[(i + f) / 2];
do {
while (arreglo[i] < pivote) {
i++;
}
while (arreglo[f] > pivote) {
f--;
}
if (i <= f) {
aux = arreglo[i];
arreglo[i] = arreglo[f];
arreglo[f] = aux;
i++;
f--;
}
} while (i <= f);
if (inicio < f) {
ordenar(arreglo, inicio, f);
}
if (i < fin) {
ordenar(arreglo, i, fin);
}
}
}

Problema: Ordenar un vector de n elementos

package quicksort;
import java.util.Random;
import java.util.Scanner;
public class PruebaQuicksort {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Nmero de elementos");
int n = sc.nextInt();
int[] v = new int[n];
generarV(v);
mostrarV(v);
QuickSort(v);
}
private static void QuickSort(int[] v) {
System.out.println("Vector ordenado");
QuickSort or = new QuickSort();
int[] numeros = v;
or.ordenar(numeros, 0, numeros.length - 1);
mostrarV(v);
}
private static void mostrarV(int[] v) {
System.out.println();
for (int i = 0; i < v.length; i++) {
System.out.println(v[i]);
}
System.out.println();
}
private static void generarV(int[] v) {
Random r = new Random();
for (int i = 0; i < v.length; i++) {
v[i] = r.nextInt(10);
}
}
}

3. ORDENAMIENTO POR MERGE SHORT

Fue desarrollado en 1945 por John Von Neumann. Conceptualmente, el
ordenamiento por mezcla funciona de la siguiente manera:
1. Si la longitud de la lista es 0 o 1, entonces ya est ordenada. En otro
caso:
2. Dividir la lista desordenada en dos sublistas de aproximadamente la
mitad del tamao.

3. Ordenar cada sublista recursivamente aplicando el ordenamiento

por mezcla.
4. Mezclar las dos sublistas en una sola lista ordenada.
El ordenamiento por mezcla incorpora dos ideas principales para
mejorar su tiempo de ejecucin:

Una lista pequea necesitar menos pasos para ordenarse que

una lista grande.
Se necesitan menos pasos para construir una lista ordenada a
partir de dos listas tambin ordenadas, que a partir de dos listas
desordenadas. Por ejemplo, slo ser necesario entrelazar cada
lista una vez que estn ordenadas.

Considere el siguiente ejemplo con una lista

[5, 2, 4, 6, 1, 3, 2, 6]
Paso 1: la lista es dividida en la primera de las dos llamadas a merge
con.
[5, 2, 4, 6]

[1, 3, 2, 6]

Paso 2: despus nuevamente es dividida.

[5, 2]

[ 4, 6]

[1, 3]

[ 2, 6]

Paso 3: se intercala obteniendo.

[2, 5]

[ 4, 6]

[1, 3]

[ 2, 6]

Paso 4: Luego se junta ordenadamente cada divisin.

[2, 4, 5, 6]

[1, 2, 3, 6]

Paso 5: Finalmente
[1, 2, 2, 3, 4, 5, 6, 6]

FUNCIONAMIENTO:

Pseudocdigo
MergeSort (T [ ] a, entero n)
{
si ( n>1) entonces
{
a1= a[0...n/2 -1] ; // Primera mitad
a2= a[n/2...n-1] ; // Segunda mitad
MergeSort(a1, n/2);
MergeSort(a2, n n/2);
Merge(a1,a2,a, n);
}
}
Merge(T [ ] a1,T [ ] a2, T [ ] a, entero n)
{
entero i, j, k;
i = j = k =0;
mientras(i < n/2 && j < n - n/2)
{
si(a1[i] < a2[j]) entonces
{
b[k] = a1 [i];
i++; k++;
}
sino
{
b[k] = a2[j];
j++; k++;
}
}
mientras(i < n/2)
{
b[k] = a1 [i];
i++;
k++;
}
mientras(j < n-n/2)

{
b[k] = a2 [j];
j++; k++;
}
}

CDIGO JAVA:
package merge;
import java.util.Arrays;
public class MergeSort {
public static void ordenacionMergeSort(int vec[]) {
if (vec.length <= 1)
return;
int mitad = vec.length / 2;
int izq[] = Arrays.copyOfRange(vec, 0, mitad);
int der[] = Arrays.copyOfRange(vec, mitad, vec.length);
ordenacionMergeSort(izq);
ordenacionMergeSort(der);
combinarVector(vec, izq, der);
}
public static void combinarVector(int v[], int izq[], int der[]) {
int i = 0;
int j = 0;
for (int k = 0; k < v.length; k++) {
if (i >= izq.length) {
v[k] = der[j];
j++;
continue;
}
if (j >= der.length) {
v[k] = izq[i];
i++;
continue;
}
if (izq[i] < der[j]) {
v[k] = izq[i];
i++;
} else {
v[k] = der[j];
j++;
}
}
}
}

Problema: Ordenar un vector de n elementos.

package merge;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
public class PruebaMergeSort1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Nmero de elementos");
int n = sc.nextInt();
long[] v = new long[n];
generarV(v);
mostrarV(v);
MergeSort(v);
}
private static void MergeSort(long[] v) {
System.out.println("Vector Ordenado");
ordenacionMergeSort(v);
for (int i = 0; i < v.length; i++) {
System.out.print(v[i] + " ");
}
}
private static void mostrarV(long[] v) {
System.out.println();
for (int i = 0; i < v.length; i++) {
System.out.println(v[i]);
}
System.out.println();
}
private static void generarV(long[] v) {
Random r = new Random();
for (int i = 0; i < v.length; i++) {
v[i] = r.nextInt(10);
}
}
public static void ordenacionMergeSort(long v[]) {
if (v.length <= 1)
return;
long mitad = v.length / 2;
long izq[] = Arrays.copyOfRange(v, 0, (int) mitad);
long der[] = Arrays.copyOfRange(v, (int) mitad,
v.length);
ordenacionMergeSort(izq);
ordenacionMergeSort(der);
combinarVector(v, izq, der);

}
public static void combinarVector(long v[], long izq[],
long der[]) {
int i = 0;
int j = 0;
for (int k = 0; k < v.length; k++) {
if (i >= izq.length) {
v[k] = der[j];
j++;
continue;
}
if (j >= der.length) {
v[k] = izq[i];
i++;
continue;
}
if (izq[i] < der[j]) {
v[k] = izq[i];
i++;
} else {
v[k] = der[j];
j++;
}
}
}
}

5. ORDENAMIENTO POR HEAP SHORT

El ordenamiento por heap sort es un algoritmo de ordenacin no
recursivo, no estable, con complejidad computacional
El Heap sort est basado en el uso de un tipo especial de rbol
binario (llamado apilamiento) para estructurar el proceso de
ordenamiento. La estructura de ramificacin del rbol conserva el
nmero de comparaciones necesarias en O(n log n).
Pasos del Heap:
1. Saca el valor mximo del Heap. (El de la posicin 1).
2. Pone el valor sacado en el arreglo ordenado.
3. Reconstruir el Heap con un elemento menos.
Ejemplo:

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

FUNCIONAMIENTO:

Diagrama de flujo:

CDIGO JAVA:

package heapsort;
public class HeapSort {
private static int[] a;
int n;
int left;
int right;
int largest;
public void buildheap(int[] a) {
n = a.length - 1;
for (int i = n / 2; i >= 0; i--) {
maxheap(a, i);
}
}
public void maxheap(int[] a, int i) {
left = 2 * i;
right = 2 * i + 1;
if (left <= n && a[left] > a[i]) {
largest = left;
} else {
largest = i;
}
if (right <= n && a[right] > a[largest]) {
largest = right;
}
if (largest != i) {
exchange(i, largest);
maxheap(a, largest);
}
}
public void exchange(int i, int j) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
public void sort(int[] a0) {
a = a0;
buildheap(a);
for (int i = n; i > 0; i--) {
exchange(0, i);
n = n - 1;
maxheap(a, 0);
}
}
}

Problema: Ordenar un vector de n elementos.

package heapsort;
import java.util.Random;
import java.util.Scanner;
public class PruebaHeapSort {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Ingrese nmero de elementos a
ordenar ");
int n = sc.nextInt();
int[] v = new int[n];
generarV(v);
mostrarV(v);
heapsort(v);
}
private static void heapsort(int[] v) {
System.out.println("Vector ordenado");
HeapSort m = new HeapSort();
m.sort(v);
mostrarV(v);
}
private static void mostrarV(int[] v) {
System.out.println();
for (int i = 0; i < v.length; i++) {
System.out.println(v[i]);
}
System.out.println();
}
private static void generarV(int[] v) {
Random r = new Random();
for (int i = 0; i < v.length; i++) {
v[i] = r.nextInt(10);
}
}
}

CONCLUSIONES

los algoritmos heapsort, mergesort y quicksort, son por lo general

ms veloces.
Los mtodos mencionados tienen una complejidad algortmica.
El Merge sort es muy estable cuando la cantidad de registros a
acomodar es de ndice bajo, en caso contrario gasta el doble del
espacio que ocupan inicialmente los datos.
El Shellsort no requiere de memoria adicional, adems que es de
mejor rendimiento que el mtodo de insercin.

REFERENCIAS
Y. Langsam, M. J. Augenstein, A. Tenenbaum. Data Structures using C
and C++. Prentice Hall, Second edition. ISBN 0-13-036997-7.
Csar Liza vila, Estructuras De Datos Con C++.
Rosita Wachenchauzer, Margarita Manterola, Maximiliano Curia, Marcos
Medrano, Nicols Paez, Algoritmos de Programacin con Python.
Pginas visitadas
https://es.wikipedia.org/wiki/Ordenamiento_por_mezcla