Métodos

de
Ordenación
Contenido

CAPITULO I ............................................................................................................ 3
INTEGRANTES
1.1 Introducción ................................................................................................. 5
1.2 Planteamiento del problema ....................................................................... 5
1.2.1 Objetivos................................................................................................ 5
1.2.2 Objetivos Generales ............................................................................. 5
1.2.3 Objetivos Específicos ........................................................................... 5
1.2.3.1 Capitulo 1 ........................................................................................ 5
1.2.3.2 Capitulo 2 ........................................................................................ 6
1.2.3.3 Capitulo 3 ........................................................................................ 6
1.3 Importancia y Justificación ........................................................................ 6
CAPITULO 2 ........................................................................................................... 6
Métodos de Ordenación........................................................................................ 6
2.1 Concepto ...................................................................................................... 6
2.2 Clasificación ................................................................................................ 6
2.2.1 Clasificación Especifica ....................................................................... 6
2.2.1.1 Algoritmos de Ordenamiento Lineal ................................................ 6
2.2.1.1.1 Ordenación por intercambio o de Burbuja (Buble sort) .............. 6
2.2.1.1.2 Ordenacion por Inserción ( Insertion Sort) .................................. 9
2.2.1.1.3 Ordenacion por Selección ( Selection Sort) ............................... 11
2.2.1.1.4 Ordenación por el método de Shell ( Shell Sort ) ...................... 14
2.2.1.2 Algoritmos de ordenamiento Recursivo ........................................ 15
2.2.1.2.1 Ordenación por mezclas ( Merge Sort ) ...................................... 15
2.2.1.2.2 Ordenación Rápida ( Quick Sort) ................................................ 18
CAPITULO III ........................................................................................................ 21
Análisis y Alcances ............................................................................................. 21
Resumen .............................................................................................................. 21
4.1 Esquema Comparativo .............................................................................. 22
4.2 Conclusiones y Recomendaciones ........................................................ 24

Página 2
INTEGRANTES

 Huayhua Huamani, Roberto

 Huaylla Huillca, Jean Piero
 Quispe Flores, Yaan carlos
 Rivera Mamani, Hans Anthony
 Sarcco Cucho, Jeferson
 Vera Cuno, Angela Pamela

Página 3
CAPITULO I

Página 4
 1.1 Introducción

Este tema trata de mirar el mundo que nos rodea e inventar maneras inteligentes
para simular ese mundo con código.

Ahora, la palabra vector puede significar muchas cosas diferentes. En el lenguaje

de programación como el C++ o el java, un vector (es una implementación de una
estructura de datos de arreglos que puede cambiar dinámicamente su tamaño).Y
Ordenar es simplemente colocar información de una manera especial basándonos
en un criterio de ordenamiento. El propósito principal de un ordenamiento es el de
facilitar las búsquedas de los registros del conjunto ordenado. Un ordenamiento es
conviene usarlo cuándo se requiere hacer una cantidad considerable de
búsquedas y es importante el factor tiempo.

Es importante destacar que existen diferentes técnicas de ordenamiento como lo

es; El Método Burbuja, que consiste en comparar pares de valores de llaves;
Método Selección, el cual consiste en encontrar el menor de todos los elementos
del arreglo e intercambiarlo; y por último el Método Intercalación, con el cual se
combinan los sub-archivos ordenados en una sola ejecución.

1.2 Planteamiento del problema

 Cuándo se requiere hacer una cantidad considerable de búsquedas y es
importante el factor tiempo.
 Uso de memoria y otros recursos computacionales.
1.2.1 Objetivos.
1.2.2 Objetivos Generales

 Conocer y manejar diferentes métodos de ordenación.

 Realizar ejecuciones de pruebas de escritorio y en ejecución.
 Determinar las ventajas y desventajas mediante una aplicación y el
tiempo de respuesta.
 Buscar la eficiencia de los diferentes programas.
 Es que las personas vean que con ingenio y con materiales simples
de consulta se puede crear ideas geniales que no solo nos ayuden a
nosotros sino a cientos de personas que requieran de esta
información, ya que para crear un mundo de programación es
necesario hacer conexiones, en este caso conexiones sociales.
1.2.3 Objetivos Específicos
1.2.3.1 Capitulo 1

Página 5
  Introducir al tema de ordenamiento de vectores
1.2.3.2 Capitulo 2
 Elaborar un proyecto acerca del algoritmo de ordenamiento en
programación, mediante la utilización de recursos científicos, didácticos y
multimedia para estructurar su uso y aplicación adecuada.
1.2.3.3 Capitulo 3
 Elaborar secuencialmente comparaciones acerca de los diferentes métodos
de ordenación
1.3 Importancia y Justificación

Los métodos de ordenamiento de datos son muy útiles, ya que la forma de

arreglar los registros de una tabla en algún orden secuencial de acuerdo a un
criterio de ordenamiento, el cual puede ser numérico, alfabético o alfanumérico,
ascendente o descendente. Nos facilita las búsquedas de cantidades de registros
en un moderado tiempo, en modelo de eficiencia. Mediante sus técnicas podemos
colocar listas detrás de otras y luego ordenarlas, como también podemos
comparar pares de valores de llaves, e intercambiarlos si no se encuentran en sus
posiciones correctas.

CAPITULO 2

Métodos de Ordenación
2.1 Concepto

Se refiere a programas los cuales tienen la función de ordenar los diferentes

elementos de un array, esto resulta necesario en el campo de la informática,
surgiendo así distintos métodos que se mencionaran a continuación
2.2 Clasificación
2.2.1 Clasificación Especifica
2.2.1.1 Algoritmos de Ordenamiento Lineal
2.2.1.1.1 Ordenación por intercambio o de Burbuja (Buble sort)
2.2.1.1.1.1 Historia o Antecedentes

Determinar con exactitud el origen del ordenamiento burbuja es un poco

complicado, ya que no existe información precisa sobre su origen.
Aunque en 1956 se encuentra expresado en un artículo al que llamaron
“ordenamiento por intercambio”.
Existe una amplia bibliografía de artículos del año 1962 donde mencionan tipos de
ordenamiento basados en este patrón, pero ninguno de ellos usando el nombre
como tal.

Página 6
Sin evidente origen definitivo, el nombre "burbuja“ se cierran sus orígenes
mediante la consulta de los primeros artículos de revistas así como textos
profesionales y pedagógicos de esta época.
2.2.1.1.1.2 Funcionamiento

Funciona de la siguiente manera:

Se va comparando cada elemento del arreglo con el siguiente; si un elemento es
mayor que el que le sigue, entonces se intercambian; esto producirá que en el
arreglo quede como su último elemento, el más grande.
Este proceso deberá repetirse recorriendo todo el arreglo hasta que no ocurra
ningún intercambio.
Los elementos que van quedando ordenados ya no se comparan. "Baja el más
pesado". Consiste en comparar pares de elementos adyacentes e intercambiarlos entre
sí hasta que estén todos ordenados.

Sea un array de 6 números de empleados: {40, 21, 4, 9, 10,35}:

Primera pasada:
{21, 40, 4, 9, 10,35} <-- Se cambia el 21 por el 40.
{21, 4, 40, 9, 10,35} <-- Se cambia el 40 por el 4.
{21, 4, 9, 40, 10,35} <-- Se cambia el 9 por el 40.
{21, 4, 9, 10, 40,35} <-- Se cambia el 40 por el 10.
{21, 4, 9, 10, 35,40} <-- Se cambia el 35 por el 40.
Segunda pasada:
{4, 21, 9, 10, 35,40} <-- Se cambia el 21 por el 4.
{4, 9, 21, 10, 35,40} <-- Se cambia el 9 por el 21.
{4, 9, 10, 21, 35,40} <-- Se cambia el 21 por el 10.
Ya están ordenados, pero para comprobarlo habría que acabar esta segunda
comprobación y hacer una tercera.
El método de Ordenamiento por intercambio en Java es el siguiente:

public class burbuja

{
public static void main(String arg[]) throws IOException
{
/*creacion del objeto para leer por teclado*/
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

Página 7
 /*ingreso del tamaño de arreglos*/
System.out.print("\n Ingrese Numero de Datos a Ingresar : ");
int tam = Integer.parseInt(in.readLine());
/*creacion del arreglo*/
int arr[] = new int[tam];
System.out.println();
/*lectura del arreglo*/
int j = 0;
for (int i = 0 ; i < arr.length;i++)
{
j+=1;
System.out.print("Elemento " + j + " : ");
arr[i] = Integer.parseInt(in.readLine());
}
burbuja(arr);
}

static void burbuja(int arreglo[])

{
for(int i = 0; i < arreglo.length - 1; i++)
{
for(int j = 0; j < arreglo.length - 1; j++)
{
if (arreglo[j] < arreglo[j + 1])
{
int tmp = arreglo[j+1];
arreglo[j+1] = arreglo[j];
arreglo[j] = tmp;
}
}
}
for(int i = 0;i < arreglo.length; i++)
{
System.out.print(arreglo[i]+"\n");
}
}
}

2.2.1.1.1.3 En la práctica

El ordenamiento de burbuja es asintóticamente equivalente en tiempos de

ejecución con el ordenamiento por inserción en el peor de los casos, pero ambos
algoritmos difieren principalmente en la cantidad de intercambios que son
necesarios. Resultados experimentales como los descubiertos por Astrachan han
demostrado que el ordenamiento por inserción funciona considerablemente mejor
incluso con listas aleatorias. Por esta razón, muchos libros de algoritmos
modernos evitan usar el ordenamiento de burbuja, reemplazándolo por el
ordenamiento por inserción.

Página 8
El ordenamiento de burbuja interactúa vagamente con el hardware de las CPU
modernas. Requiere al menos el doble de escrituras que el ordenamiento por
inserción, el doble de pérdidas de caché, y asintóticamente más predicción de
saltos. Varios experimentos de ordenamiento de cadenas en Java hechos por
Astrachan muestran que el ordenamiento de burbuja es 5 veces más lento que
el ordenamiento por inserción, y 40% más lento que el ordenamiento por
selección.
2.2.1.1.1.4 Ventajas
 Es bastante sencillo
 En un código reducido
 Se realiza el ordenamiento
 Eficaz
2.2.1.1.1.5 Desventajas

 Consume bastante tiempo de computadora

 Requiere muchas lecturas/escrituras en memoria

2.2.1.1.2 Ordenacion por Inserción ( Insertion Sort)

2.2.1.1.2.1 Historia o Antecedentes

Es una manera muy natural de ordenar para un ser humano, y puede usarse
fácilmente para ordenar un mazo de cartas numeradas en forma arbitraria.
Requiere O(n²) operaciones para ordenar una lista de n elementos.

Inicialmente se tiene un solo elemento, que obviamente es un conjunto ordenado.

Después, cuando hay k elementos ordenados de menor a mayor, se toma el
elemento k+1 y se compara con todos los elementos ya ordenados, deteniéndose
cuando se encuentra un elemento menor (todos los elementos mayores han sido
desplazados una posición a la derecha) o cuando ya no se encuentran elementos
(todos los elementos fueron desplazados y este es el más pequeño). En este
punto se inserta el elemento k+1 debiendo desplazarse los demás elementos.

2.2.1.1.2.2 Clasificación
 Ordenacion por Inserción Directa

El método de ordenación por inserción directa consiste en recorrer todo el array

comenzando desde el segundo elemento hasta el final. Para cada elemento, se
trata de colocarlo en el lugar correcto entre todos los elementos anteriores a él o
sea entre los elementos a su izquierda en el array.

Dada una posición actual p, el algoritmo se basa en que los elementos A[0], A[1],
..., A[p-1] ya están ordenados.

Página 9
De forma gráfica el proceso que sigue el método de inserción directa es el
siguiente

El método de Ordenamiento por inserción directa en Java es el siguiente:

public static void insercionDirecta(int A[]){
int p, j;
int aux;
for (p = 1; p < A.length; p++){ // desde el segundo elemento hasta
aux = A[p]; // el final, guardamos el elemento y
j = p - 1; // empezamos a comprobar con el anterior
while ((j >= 0) && (aux < A[j])){ // mientras queden posiciones y
el
// valor de aux sea menor que los
A[j + 1] = A[j]; // de la izquierda, se desplaza a
j--; // la derecha
}
A[j + 1] = aux; // colocamos aux en su sitio
}
}

 Ordenacion por Insercion Binaria

class BusquedaAlgoritmo {
public static int buscar( int [] arreglo, int dato) {
int inicio = 0;
int fin = arreglo.length - 1;
int pos;
while (inicio <= fin) {

Página
10
 pos = (inicio+fin) / 2;
if ( arreglo[pos] == dato )
return pos;
else if ( arreglo[pos] < dato ) {
inicio = pos+1;
} else {
fin = pos-1;
}
}
return -1;
}
}

2.2.1.1.2.3 Ventajas
 Es un algoritmo sencillo de entender y de codificar.
 Si el tamaño de la entrada es N, entonces el orden del tiempo de ejecución,
para elpeor caso es O(N2);
 Si la entrada esta "casi ordenada", el algoritmo se ejecuta mucho más
rápidamente.
 Esta velocidad tiende a un tiempo O(N), peor caso que se cumple cuando la
entrada está totalmente ordenada.
 Es por la propiedad anterior que este algoritmo, a pesar de no ser el más
rápido para entradas grandes, suele usarse de la siguiente manera: Se
semi ordena la entrada con algún otro algoritmo más rápido y más
adecuado para entradas grandes. Luego, cuando tenemos la entrada "casi
ordenada" usamos este algoritmo. La velocidad de ejecución será muy
buena por dos razones: su tiempo de ejecución tiende a O(N) con entradas
"casi ordenadas" (lo cual es un tiempo excelente), y la simpleza de su
implementación hará que se ejecute más rápido que otros algoritmos más
complejos.

2.2.1.1.2.4 Desventajas
 No funciona tan bien como otros algoritmos mejores de ordenamiento. Con
n al cuadrado pasos requeridos para cada n elemento a ser ordenado, este
algoritmo no funciona bien con una lista grande. Por lo tanto, este sólo es
útil cuando se ordena una lista de pocos elementos.

2.2.1.1.3 Ordenacion por Selección ( Selection Sort)

Página
11
Este algoritmo trabaja seleccionando el dato más pequeño a ser ordenado que
aún está en la lista, y luego haciendo un intercambio con el elemento en la
siguiente posición.

2.2.1.1.3.1 Desarrollo

Su funcionamiento es el siguiente:

 Buscar el mínimo elemento de la lista

 Intercambiarlo con el primero
 Buscar el siguiente mínimo en el resto de la lista
 Intercambiarlo con el segundo
Y en general:

 Buscar el mínimo elemento entre una posición i y el final de la lista

 Intercambiar el mínimo con el elemento de la posición i

Ejemplo, si tenemos el array {40, 21, 4, 9, 10,35}, los pasos a seguir son
:

{4, 21, 40, 9, 10,35} <-- Se coloca el 4, el más pequeño, en primera posición: se
cambia el 4 por el 40.
{4, 9, 40, 21, 10,35} <-- Se coloca el 9, en segunda posición: se cambia el
9 por el 21.
{4, 9, 10, 21, 40,35} <-- Se coloca el 10, en tercera posición: se cambia el 10 por el
40.
{4, 9, 10, 21, 40,35} <-- Se coloca el 21, en tercera posición: ya está colocado.
{4, 9, 10, 21, 35,40} <-- Se coloca el 35, en tercera posición: se cambia el 35 por el
40.

class seleccion{

public static void ordenar(int[] arreglo){

int contador = 1;//solo util para contar las comparaciones

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

Página
12
 int min = i;

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

//System.out.println("Comparación #" + contador);

contador++; if (arreglo[j] < arreglo[min]){ min = j; } }

if (i != min)

int aux= arreglo[i];

arreglo[i] = arreglo[min];

arreglo[min] = aux;

public static void imprimirLista(int[] arreglo)

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

System.out.print(arreglo[i]+",");

System.out.println();

public static void main(String[] args){

int lista[] = {40,21,4,9,10,35};

System.out.print("Lista desordenada: ");

imprimirLista(lista);

ordenar(lista);

System.out.print("Lista ordenada: ");

imprimirLista(lista);

2.2.1.1.3.2 Ventajas
 ES fácil su implementación,
 No requiere memoria adicional
 Realiza pocos intercambios

Página
13
  Tiene un rendimiento constante

2.2.1.1.3.3 Desventajas
 Es lento y poco eficiente cuando se utiliza listas grandes o
medianas(realiza numerosas comparaciones)

2.2.1.1.4 Ordenación por el método de Shell ( Shell Sort )

2.2.1.1.4.1 Historia o Antecedentes

El método de ordenación Shell debe su nombre a su inventor, Donald Shell, y fue

uno de los primeros algoritmos de ordenamiento en romper la barrera del tiempo
cuadrático.

2.2.1.1.4.2 Desarrollo

El método Shell de ordenación en Java para ordenar un array A de enteros es el

siguiente:
public static void shell(int A[]){
int salto, aux, i;
boolean cambios;
for(salto=A.length/2; salto!=0; salto/=2){
cambios=true;
while(cambios){ // Mientras se intercambie algún elemento
cambios=false;
for(i=salto; i< A.length; i++) // se da una pasada
if(A[i-salto]>A[i]){ // y si están desordenados
aux=A[i]; // se reordenan
A[i]=A[i-salto];
A[i-salto]=aux;
cambios=true; // y se marca como cambio.
}
}
}
}

2.2.1.1.4.3 Ventajas

Página
14
 • Cualquier algoritmo de ordenación que intercambia elementos
adyacentes (como los algoritmos burbuja, selección o inserción) tiene un
tiempo promedio de ejecución de orden cuadrático (n2). El método Shell
mejora este tiempo comparando cada elemento con el que está a un cierto
número de posiciones llamado salto, en lugar de compararlo con el el que
está justo a su lado. Este salto es constante, y su valor inicial es N/2 (siendo
N el número de elementos, y siendo división entera).

• Es una mejora del método de inserción directa, utilizado cuando el

array tiene un gran número de elementos.
• No requiere memoria adicional.
• Mejor rendimiento que el método de Inserción clásico
• veces más rápido que bubble sort.
• 2 veces más rápido que insertion sort.

2.2.1.1.4.4 Desventajas

• Implementación algo confusa.

• Realiza numerosas comparaciones e intercambios.
• Shell Sort es significativamente mas lento que merge, heap y quick sort.

2.2.1.2 Algoritmos de ordenamiento Recursivo

2.2.1.2.1 Ordenación por mezclas ( Merge Sort )
2.2.1.2.1.1 Historia o Antecedentes

El método MergeSort es un algoritmo de ordenación recursivo con un número de

comparaciones entre elementos del array mínimo.
Su funcionamiento es similar al Quicksort, y está basado en la técnica divide y
vencerás.
2.2.1.2.1.2 Desarrollo

De forma resumida el funcionamiento del método MergeSort es el siguiente:

 Si la longitud del array es menor o igual a 1 entonces ya está ordenado.
 El array a ordenar se divide en dos mitades de tamaño similar.
 Cada mitad se ordena de forma recursiva aplicando el método MergeSort.
 A continuación las dos mitades ya ordenadas se mezclan formando una
secuencia ordenada.

La ordenación mergesort se puede implementar en Java de la siguiente forma:

Página
15
public static void mergesort(int A[],int izq, int der){
if (izq<der){
int m=(izq+der)/2;
mergesort(A,izq, m);
mergesort(A,m+1, der);
merge(A,izq, m, der);
}
}

El método ordena un array A de enteros desde la posición izq hasta la posición

der. En la primera llamada al método recibirá los valores izq = 0, der =
ELEMENTOS-1.
Primero se calcula el elemento central m. A continuación la primera parte del
array, desde izq hasta m y la segunda parte del array, desde m+1 hasta der, se
mezclan mediante llamadas recursivas al método mergesort.
La recursión termina cuando izq == der, es decir, cuando un subarray contiene
solamente un elemento.
La operación principal de mezcla la realiza el método merge. Este método se
puede implementar de varias formas, la más usual es la siguiente:

public static void merge(int A[],int izq, int m, int der){

int i, j, k;
int [] B = new int[A.length]; //array auxiliar
for (i=izq; i<=der; i++) //copia ambas mitades en el array auxiliar
B[i]=A[i];

i=izq; j=m+1; k=izq;

while (i<=m && j<=der) //copia el siguiente elemento más grande
if (B[i]<=B[j])
A[k++]=B[i++];
else
A[k++]=B[j++];
while (i<=m) //copia los elementos que quedan de la
A[k++]=B[i++]; //primera mitad (si los hay)
}
De forma gráfica podemos representar el funcionamiento del algoritmo de la
siguiente forma:

Página
16
 2.2.1.2.1.3 Ventajas

 Método de ordenamiento estable mientras la función de mezcla sea

implementada correctamente.
 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.
 Efectivo para conjunto de datos a los que se puede acceder
secuencialmente (arreglos, vectores, etc.)

2.2.1.2.1.4 Desventajas

Está definido recursivamente. Si se deseara implementarla no recursivamente se

tendría que emplear una pila y se requeriría un espacio adicional de memoria para
almacenarla.

Página
17
 2.2.1.2.2 Ordenación Rápida ( Quick Sort)
2.2.1.2.2.1 Historia o Antecedentes

Este algoritmo nace como una necesidad para reunir datos estadísticos.
 1945- Zuse desarrolla un programa de
clasificación por inserción directa.

 1946- John Mauchly mayor velocidad en

procesos de clasificación. Demostró que a
clasificación es útil con los cálculos
numéricos.

A partir de aquí se desarrollan los algoritmos de

clasificación binaria y por inserción directa.
Charles Antony Richard Hoare
 1960 - Sir Charles Antony Richard Hoare, Tony
Hoare o CAR Hoare, nacido 11 de enero 1934 es un
científico informático británico, probablemente el más
conocido para el desarrollo en 1960 de Quicksort (o
Hoaresort),uno de los más utilizados algoritmos
de ordenación del mundo.

2.2.1.2.2.2 Desarrollo

Se basa en la técnica divide y vencerás, que consiste en ir subdividiendo el array

en arrays más pequeños, y ordenar éstos. Para hacer esta división, se toma un
valor del array como pivote, y se mueven todos los elementos menores que este
pivote a su izquierda, y los mayores a su derecha. A continuación se aplica el
mismo método a cada una de las dos partes en las que queda dividido el array.
2.2.1.2.2.2.1 Funcionamiento
 Se elige un elemento v de la lista L de elementos al que se le llama pivote.
 Se particiona la lista L en tres listas:
 L1 - que contiene todos los elementos de L menos v que sean menores o
iguales que v
 L2 - que contiene a v
 L3 - que contiene todos los elementos de L menos v que sean mayores o
iguales que v

Página
18
  Se aplica la recursión sobre L1 y L3
 Se unen todas las soluciones que darán forma final a la lista L finalmente
ordenada. Como L1 y L3 están ya ordenados, lo único que tenemos que
hacer es concatenar L1, L2 y L3

Aunque este algoritmo parece sencillo, hay que implementar los pasos 1 y 3 de
forma que se favorezca la velocidad de ejecución del algoritmo.
Suponiendo que tomamos como pivote el primer elemento, el método Java
Quicksort que implementa este algoritmo de ordenación para ordenar un array de
enteros se presenta a continuación. Los parámetros izq y der son el primer y
último elemento del array a tratar en cada momento.
El método ordena un array A de enteros desde la posición izq hasta la
posición der. En la primera llamada recibirá los valores izq = 0, der =
ELEMENTOS-1.
public static void quicksort(int A[], int izq, int der) {

int pivote=A[izq]; // tomamos primer elemento como pivote

int i=izq; // i realiza la búsqueda de izquierda a derecha
int j=der; // j realiza la búsqueda de derecha a izquierda
int aux;

while(i<j){ // mientras no se crucen las búsquedas

while(A[i]<=pivote && i<j) i++; // busca elemento mayor que pivote
while(A[j]>pivote) j--; // busca elemento menor que pivote
if (i<j) { // si no se han
cruzado
aux= A[i]; // los intercambia
A[i]=A[j];
A[j]=aux;
}
}
A[izq]=A[j]; // se coloca el pivote en su lugar de forma que tendremos
A[j]=pivote; // los menores a su izquierda y los mayores a su derecha
if(izq<j-1)
quicksort(A,izq,j-1); // ordenamos subarray izquierdo
if(j+1 <der)
quicksort(A,j+1,der); // ordenamos subarray derecho
}

Una interpretación gráfica a considerar sería:

Página
19
La elección del pivote determinará la eficiencia de este algoritmo ya que determina
la partición del array. Si consideramos que el array está desordenado, podemos
elegir el primer elemento y el algoritmo funcionaría de forma eficiente. Pero si el
array está casi ordenado, elegir el primer elemento como pivote sería una mala
solución ya que obtendríamos un subarray muy pequeño y otro muy grande. Por la
misma razón, elegir el último elemento del array como pivote también es una mala
idea. Pretendemos conseguir que el tamaño de los subarrays sea lo más parecido
posible.

Una alternativa a elegir el primer elemento es elegir como pivote un elemento al

azar de entre todos los del array.
Otra estrategia es calcular la mediana de los valores de la izquierda, centro y
derecha del vector.
Por ejemplo para el vector 9 8 1 6 10 2 3, se calcula la mediana de los elementos
que ocupan el primer lugar, el último y el centro o sea 9 3 6. La mediana es 6 que
determinaría las particiones {1 3 2} {6} {8 10 9}.
2.2.1.2.2.2.2 Características especiales

En la práctica, es el algoritmo de ordenación más rápido conocido, su tiempo

de ejecución promedio es O(n log (n)), cabe resaltar que en el peor de los casos
O(n2), caso altamente improbable. El hecho de que sea más rápido que otros
algoritmos de ordenación con tiempo promedio de O(n log (n)) ( como SmoothSort
o HeapSort ) viene dado por que QuickSort realiza menos operaciones ya que el
método utilizado es el de partición.
2.2.1.2.2.3 Ventajas

Página
20
  Muy rápido.
 No requiere memoria adicional.
2.2.1.2.2.4 Desventajas
 Implementación un poco más complicada.
 Recursividad (utiliza muchos recursos).
 Mucha diferencia entre el peor y el mejor caso.

CAPITULO III

Análisis y Alcances

Resumen
Por ordenar se entiende el proceso de reorganizar un conjunto de objetos
en una cierta secuencia de acuerdo a un criterio especificado. En general,
el objetivo de este proceso es facilitar la posterior búsqueda de elementos
en el conjunto ordenado.

Existen múltiples ejemplos reales de conjuntos que requieren ser

ordenados: la guía telefónica, índices de libros, ficheros de bibliotecas,
diccionarios, ficheros de diverso tipo en oficinas, actas de exámenes, etc.
Debido a que las estructuras de datos son utilizadas para almacenar
información, para poder recuperar esa información de manera eficiente es
deseable que aquella esté ordenada. Existen varios métodos para ordenar
las diferentes estructuras de datos básicas.
En general los métodos de ordenamiento no son utilizados con frecuencia,
en algunos casos sólo una vez. Hay métodos muy simples de implementar
que son útiles en los casos en dónde el número de elementos a ordenar no
es muy grande (ej, menos de 500 elementos). Por otro lado hay métodos
sofisticados, más difíciles de implementar pero que son más eficientes en
cuestión de tiempo de ejecución.

Los métodos sencillos por lo general requieren de aproximadamente n x n

pasos para ordenar n elementos.

Los métodos simples son: insertion sort (o por inserción directa) selection
sort, bubble sort, y shellsort, en dónde el último es una extensón al insertion
sort, siendo más rápido. Los métodos más complejos son el quick-sort, el
heap sort, radix y address-calculation sort. El ordenar un grupo de datos
significa mover los datos o sus referencias para que queden en una

Página
21
 secuencia tal que represente un orden, el cual puede ser numérico,
alfabético o incluso alfanumérico, ascendente o descendente.

Se ha dicho que el ordenamiento puede efectuarse moviendo los registros

con las claves. El mover un registo completo implica un costo, el cual se
incrementa conforme sea mayor el tamaño del registro. Es por ello que es
deseable evitar al máximo el movimiento de los registros. Una alternativa es
el crear una tabla de referencias a los registros y mover las referencias y no
los datos. A continuación se mostrarán los métodos de ordenamiento
empezando por el más sencillo y avanzando hacia los mas sofisticados
La eficiencia de los algoritmos se mide por el número de comparaciones e
intercambios que tienen que hacer, es decir, se toma n como el número de
elementos que tiene el arreglo a ordenar y se dice que un algoritmo realiza
O(n2) comparaciones cuando compara n veces los n elementos, n x n = n2.

4.1 Esquema Comparativo

Página
22
Página
23
4.2 Conclusiones y Recomendaciones
 Eligiendo el más adecuado. No existe EL ALGORITMO de ordenamiento.
Sólo existe el mejor para cada caso particular. Debe conocerse a fondo el
problema a resolver, y aplicar el más adecuado. Aunque hay algunas
preguntas que pueden ayudar a elegir:
 ¿Qué grado de orden tendrá la información que va a manejar? Si la
información va a estar casi ordenada y no desea complicarse, un algoritmo
sencillo como el ordenamiento burbuja será suficiente. Si por el contrario los
datos van a estar muy desordenados, un algoritmo poderoso como
Quicksort puede ser el más indicado.
 Y si no puede hacer una presunción sobre el grado de orden de la
información, lo mejor será elegir un algoritmo que se comporte de manera
similar en cualquiera de estos dos casos extremos.

Página
24
 ¿Qué cantidad de datos va a manipular? Si la cantidad es pequeña, no es
necesario utilizar un algoritmo complejo, y es preferible uno de fácil
implementación. Una cantidad muy grande puede hacer prohibitivo utilizar
un algoritmo que requiera de mucha memoria adicional.
 ¿Qué tipo de datos quiere ordenar? Algunos algoritmos sólo funcionan con
un tipo específico de datos (enteros, enteros positivos, etc.) y otros son
generales, es decir, aplicables a cualquier tipo de dato.
 ¿Qué tamaño tienen los registros de la lista? Algunos algoritmos realizan
múltiples intercambios (burbuja, inserción). Si los registros son de gran
tamaño estos intercambios son más lentos.

Página
25