Estructura de Datos

Métodos de Ordenamiento de Vectores

Integrantes:

Carlos Bustos G.
Angelo Etcheverry M.

15 de junio de 2010
.- Introducción

Los métodos de ordenamiento, nos servirán para ordenar un vector al que se le

asignaron valores en forma no ordenada.

Analizaremos el funcionamiento, así como también la complejidad de cada

algoritmo de los 4 métodos distintos de ordenamiento que conoceremos en este
informe: Selección, Inserción, Burbuja y Quicksort (Rápido) siendo los 3 primeros
iterativos y el último recursivo.

Además también conoceremos cual de los métodos de ordenamiento es el más

preciso y eficiente y cual es el más lento e impreciso.
1.- Método de Selección (SelectionSort)

Subvector Ordenado x min

3 9 54 53 68 32

Subvector no Ordenado

Donde:

x: es el primer elemento del subvector no ordenado y

min: es la posición del elemento de valor más pequeño.

Ejemplo:

52 9 3 87 21
0 1 2 3 4

3 9 52 87 21
x, min

3 9 52 87 21
x min

3 9 21 87 52
x min

3 9 21 52 87

El método de ordenación por selección funciona seleccionando el menor elemento

del vector y llevándolo a la posición 0; luego selecciona el siguiente menor y lo
pone en la posición 1 del vector y así sucesivamente.
 public void ordenar_Seleccion(){

int aux, pos_min;

for(int i = 0; i < (vector.length-1); i++){

pos_min = i;

for(int j = i+1; j < vector.length; j++){

if(vector[j] < vector[pos_min]){
pos_min = j;
}

aux = vector[i];
vector[i] = vector[pos_min];
vector[pos_min] = aux;

}
}

Algoritmo:

El algoritmo del método de ordenamiento por Selección es un algoritmo simple y

fácil de implementar ya que consiste en 2 bucles.

El primer bucle for es el que realiza las iteraciones, indica el inicio del subvector
ordenado y se encarga de llevar el elemento de menor valor a la primera posición
del subvector no ordenado.

El segundo bucle for es el que encuentra el elemento de menor valor.

Complejidad:

La complejidad de este método es de O(n2) en el peor y mejor de los casos ya que

siempre realiza el mismo numero de comparaciones e intercambios para un n
dado, aun si el vector ya esta parcialmente ordenado.

n = tamaño del vector.

Conclusión:

La enorme cantidad de comparaciones y los pocos intercambios hacen que este

método no sea muy bueno en comparación con otros métodos de ordenación.

Así en general su utilización se restringe para el ordenamiento de unos pocos

datos mediante una implementación sencilla y fácil de recordar.
2.- Método de Inserción (InsertionSort)
Insertar

15 93 45 8 32 56

Subvector Ordenado Subvector no ordenado

Para el método de inserción compararemos el primer elemento del subvector no ordenado

con el resto que esta ya ordenado. (en gris).

15 93 45 8
1.- Iteración: comparamos 93 con el anterior. ¿93 < 15? No, como están en orden
pasamos a la siguiente iteración.
15 93 45 8

2.- Iteración: ¿45 < 93? Si, entonces los intercambiamos.

15 45 93 8

¿45 < 15? No, como están en orden pasamos a la siguiente iteración.

15 45 93 8

3.- Iteración: Comparemos el 8 con su anterior (93). ¿8 < 93? Si, entonces
intercambiamos.
15 45 8 93

Comparamos el 8 con su anterior (45). ¿8<45? Si, entonces intercambiamos.

15 8 45 93

Comparamos el 8 con su anterior (15). ¿8<15? Si, entonces volvemos a intercambiar.

8 15 45 93

Como no quedan elementos menores a 8, pasamos a la siguiente iteración. Fin

8 15 45 93
Public void Ordenar_Insercion(){

int aux;

for(int i = 1; i < vector.length; i++){

aux = vector[i];

for(int j = i; (j>0) && (aux < vector[j-1]); j++){

vector[j] = vector[j-1];

vector[j-1] = aux;

}
}
}

Algoritmo:

Observamos que el bucle for principal recorre todos los elementos del vector
desde i = 1 (segundo elemento) hasta el n-ésimo. Mientras que el bucle for
secundario compara el elemento con su anterior y en caso de ser menor lo inserta
en su respectivo lugar entre sus predecesores (Subvector Ordenado).

Complejidad:

Este método requiere O(n²) operaciones para ordenar un vector de n elementos. A

diferencia del método SelectionSort, este método aprovecha una posible
ordenación parcial del vector.

Conclusión:

El método de ordenamiento por Inserción (InsertSort) es el método más rápido de

y eficaz de los 3 métodos de ordenamiento de complejidad cuadrática.
3.- Método Burbuja (Bubblesort)
Subvector Ordenado ¿8 < 10? Intercambiamos.
3 20 17 10 8

Subvector no Ordenado

Ejemplo:
20 8 10 3

1.- Iteración:

¿3 < 10? Si, intercambiamos.

20 8 3 10

¿3 < 8? Si, intercambiamos.

20 3 8 10

¿3 < 20? Si, intercambiamos y pasamos a la siguiente iteración. (10) es el nuevo ‘ultimo’
3 20 8 10

2.- Iteración:
¿10 < 8? No intercambiamos.
3 20 8 10

Ahora comparamos 8 con su anterior. ¿8 < 20? Si, intercambiamos.

Como no quedan elementos menores a 8, pasamos a la siguiente iteración.

3 8 20 10
3.- iteración:

¿10 < 20? Si, entonces intercambiamos. Como no quedan elementos menores a 10
(dentro del subvector no ordenado) pasamos a la siguiente iteración.

3 8 10 20

4.- iteración: Como 20 es el último elemento, el vector ya esto ordenado, fin.

3 8 10 20
Public void ordenar_Burbuja(){

int aux;
for(int i = 1; i < vector.length;i++){
for(int j= vector.length-1;j>=i;j--){
if(vector[j] < vector[j-1]){
aux = vector[j];
vector[j] = vector[j-1];
vector[j-1] = aux;
}
}
}
}

Algoritmo:

Este método recorre el vector de derecha a izquierda, esto quiere decir, desde el
índice (vector.length -1) hasta 0.

Tras cada iteración preguntaremos si vector [J+1] < vector[J ] es decir, ¿ es el

ultimo elemento del subvector no ordenado menor a su antecesor ? en caso de ser
así se intercambian de posición, ahora el antecesor pasa a ser el nuevo “ ultimo “.

Complejidad:

Este método requiere O(n²) operaciones para ordenar un vector de n elementos.

Conclusión:

Este método de ordenamiento es el más lento de los métodos iterativos debido a

la cantidad de comparaciones extra que ejecuta, lo que hace que sea el menos
preciso.
4.- Método Rápido (Quicksort)

Inicio pivote fin

3 8 5 2 6
0 1 2 3 4
Subvector menor a pivote Subvector mayor a pivote

Obtención del pivote:

Pivote = vector [( inicio + fin ) / 2 ] = vector [( 0 + 4 ) / 2 ] = vector [4 / 2]

= vector [2] = 5.

3 8 5 2 6 Ejemplo:

Comenzamos ordenando el subvector a la izquierda.

¿3 es menor o mayor que pivote (5)? es menor, entonces lo deja al lado izquierdo.
Luego: ¿8 es mayor o menor que pivote (5)? es mayor, entonces lo tira a su derecha. No
quedan más elementos.

Ahora ordenamos el subvector a la derecha.

¿2 es menor o mayor que pivote (5)? es menor, entonces lo tira a la izquierda. Luego ¿6
es mayor o menor que pivote (5)? es mayor, entonces lo deja al lado derecho.

3 8 5 2 6

3 2 5 8 6

Notamos que los subvectores tanto a la izquierda como derecha aun no están ordenados.
Así buscamos un nuevo pivote para cada subvector.

Pivote izquierdo: vector [(0 + 1)/2] = vector [1/2] = vector [0.5] = vector [0] = 3
Pivote derecho: vector [(3 + 4)/ 2] = vector [7/2] = vector [3.5] = vector [3] = 8

Para subvector izquierdo: ¿2 es mayor o menor que su pivote (3)? es menor, entonces lo
mueve a su izquierda.
Para subvector derecho: ¿6 es mayor o menor que su pivote (8)? es menor, entonces lo
tira a su izquierda.

3 2 5 8 6

2 3 5 6 8
public void ordenar_Quicksort(int[] vector, int izq, int der) {
int i = izq;
int j = der;
int pivote = vector[ (izq + der) / 2];
do {
while (vector[i] < pivote) {
i++;
}
while (vector[j] > pivote) {
j--;
}
if (i <= j) {
int aux = vector[i];
vector[i] = vector[j];
vector[j] = aux;
i++;
j--;
}
}
while (i <= j);
if (izq < j) {
ordenar_Quicksort(vector, izq, j);
}
if (i < der) {
ordenar_Quicksort(vector, i, der);
}
}

Algoritmo:

El método de ordenamiento rápido (QuickSort) esta basado en la teoría: divide y

vencerás, la cual implica resolver un problema difícil, dividiéndolo en partes más
simples tantas veces como sea necesario. Así mismo lo que hace este algoritmo
es dividir recursivamente el vector en partes iguales, indicando un elemento de
inicio, fin y un pivote que nos permitirá dividir nuestro vector en subvectores.

Una vez dividido, lo que hace es dejar todos los menores que el pivote a su
izquierda y a su vez todos los mayores a su derecha.

Para usar Quicksort: ordenar_Quicksort(vector, 0, vector.length-1);

Complejidad:

En el peor de los casos la complejidad del método QuickSort es de O(n 2) y en el

mejor de los casos su complejidad es de O(n log n).

Conclusión:

Las llamadas recursivas hacen que este método sea mucho más eficiente en
comparación con los métodos iterativos antes analizados y lejos el método más
rápido de ordenamiento.
.- Conclusión

Hemos concluido en este informe que de los 4 métodos de ordenamiento de

vectores analizados, el método rápido (Quicksort) es el más eficiente. No obstante
su algoritmo es el más complicado y difícil de entender (no así su funcionamiento)
debido a las llamadas recursivas que ejecuta.

En cambio por su parte los métodos de ordenamiento Iterativos poseen en su

estructura un algoritmo más simple y fácil de implementar pero también menos
eficiente.

Así de estos 3 métodos de complejidad cuadrática el más rápido es el método de

ordenamiento por Inserción, seguido por el método de Selección y en último lugar
el método más lento e impreciso: Burbuja.