ORDENAMIENTO DE

Tipo de algorito RADIX SORT
Es un ordenamiento el cual se ordenación muy ingenioso,
basado en comparaciones
basa en los valores de los
digitos reales en las
mejores resultados que los
representaciones de posiciones
D escripcio n
de los números que se ordenan.
selección directa o inserción
Este método nació de la idea de
Hernan Hollerith en el año de
1890
Shell el cual lo publico en el
*El ordenamiento es
razonablemente eficiente si el
número de dígitos en las llaves
no es demasiado grande.
*Si las máquinas tienen la
Vent ajas
ventaja de ordenar los
digitosm(sobre todo si estan
en en binario) lo ejecutarían
como mucha mas rapidez de
lo que se ejecutanuna
SHELL SORT HEAP SORT
*Es un algoritmo de ordenacion
no recursivo, nos estable,con
Es un metodo de
complejidad computacional O(n
log n).
e entonces ya está ordenada. En otro
*Consiste en almacenar todos
intercambios, y con los
los elementos del vector a
ordenar en un montículo (heap),
métodos de la burbuja,
y luego extraer el nodo que
queda como nodo raíz del
directa.
montículo (cima) en sucesivas
Fue creado por Donald
iteraciones obteniendo el
conjunto ordenado.
año de 1959.
*Fue creado por Robert W.
Floyd y Williams en el año de
1964
*Este metodo funciona mas
*No requiere de memoria efectivamente con datos
adicional. desordenados.
*5 veces más rápido que *Su desempeño es en promedio
bubble sort. tan bueno como el quicksort y
*2 veces más rápido que se comporta mejor que este
insertion sort. ultimo en los peores casos.
*Mejor rendimiento que el *No utiliza memoria adicional.
método
BURBUJA
BIDIRECCIONAL
*Es un algoritmo de
ordenamiento que surge como
una mejora del algoritmo
ordenamiento de burbuja.
*Es bastante sencillo.
*Es un codigo reducido se
realiza el ordenamieno.
*Es eficaz
*Ordena el arreglo tanto de ida
como de vuelta.
*No es necesario volver a
recorrer los elementos ya
ordenador.
MERGE SORT QUICKSORT INSERCCION SELECCIÓN BURBUJA
Este algoritmo fue creado en 1945
El método Quicksort está basado
por Jhon Von Neumann en la que la
en la técnica Divide y Vencerás, la
primera y la segunda mitades de una
cuál consiste en dividir un
matriz se ordenan de forma recursiva Este algoritmo mejora
problema en partes más pequeñas Inicialmente, se ordenan los
cada uno y luego se fusionan. ligeramente el algoritmo de
para luego resolverlas por separado dos primeros elementos de Es un ordenamiento que
Si la longitud de la lista es 0 ó 1,
y así al final unirlas ya resueltas, una matriz, luego se inserta el
la burbuja. En caso de
funciona revisando cada
tener que ordenar un
que permite, en promedio, ordenar tercer elemento en la posición elemento de la lista que va a
caso: vector de enteros, esta
n elementos en un tiempo correcta respecto a los dos ser ordenanda con el siguiente,
Dividir la lista desordenada en dos sub- mejora no es muy
proporcional a n log n primeros. A continuación, se intercambiandolos de posicion
listas de aproximadamente la mitad sustancial, pero cuando
inserta el cuarto elemento en si estan en el orden
del tamaño. hay que ordenar un vector
El algoritmo Quicksort fue la posición correcta respecto equivocado. Es necesario
Ordenar cada sub-lista de estructuras mas
desarrollado en el año 1960 por a los tres primeros elementos revisar todas las listas hasta
recursivamente aplicando el complejas, la operación de
Charles Antony Richard Hoare ya ordenados, y así que no se necesiten mas
ordenamiento por mezcla. intercambiar los elementos
mientras se encontraba en la Unión sucesivamente hasta llegar al intercambios
Mezclar las dos sub-listas en una sola seria mas costosa en este
Soviética, en la Universidad Estatal último elemento de la matriz.
lista ordenada. caso.
de Moscú.
El ordenamiento por mezcla
incorpora dos ideas principales para
mejorar su tiempo de ejecución:
*Requiere de pocos recursos en
comparación a otros métodos de
*Efectivo para conjunto de datos a los
ordenamiento.
que se puede acceder
*En la mayoría de los casos, se * Es fácil su *Este método es fácil de
secuencialmente (arreglos, vectores,
requiere aproximadamente N log *Fácil implementacion implementacion comprender, programar y es el
etc.)
N operaciones. *No requieren memoria * No requiere memoria más extendido.
*Ciclo interno es extremadamente adicional. adicional * Es bastante sencillo
*Método de ordenamiento estable
corto * Realiza pocos * En un código reducido se
mientras la función le mezcla sea
*No se requiere de espacio intercambios. realiza el ordenamiento
implementada.
adicional durante ejecución (in-
place processing).

*Muy estable cuando la cantidad de

*Se requiere conocer la
cantidad de digitos del valor
máximo(para saber cuando el
método ya acomodo todos los
elementos)
*Se require de espacio para
D esvent ajas
almacenar los punteros del
frente y la parte posterior de la
cola, además de un campo
adicional en cada registro que
se utiliza como puntero a la
lista encadenada.
registros a acomodar es de índice
bajo, en caso contrario gasta el doble *Se complica la implementación si
*Implementación algo
del espacio que ocupan inicialmente la recursión no es posible
confusa.
*Requiere muchas los datos. *Un simple error en la *Es uno de los menos
*Realiza numerosas *Es lento y poco eficiente
*Es un metodo complejo. lecturas/escritura en memoria. implementación puede pasar sin eficientes y por ello,
comparaciones e *Muy lento cuando se usa en listas
*No es estable,ya que se *Consume bastante recursos de *Está definido recursivamente. Si se detección, lo que provocaría un normalmente, se aprende su
intercambios. *Muchas comparaciones. grandes o medianas.
comporta de manera ineficaz computadora. deseara implementarla no rendimiento pésimo. tactica pero no se utiliza
*Shell Sort es *Muchos intercambios. *Realiza numerosas
con datos del mismo valor. *Realiza muchas recursivamente se tendría que *Se pierde el orden relativo de *Consume bastante tiempo de
significativamente mas lento comparaciones
comprobaciones. emplear una pila y se requeriría un elementos idénticos. computadora "ejecuación"
que merge, heap y quick
espacio adicional de memoria para
sort.
almacenarla.

El pivote termina en el centro de

Mejo r d e lo s caso s
En este método no requiere
metodo adicional del cual
brinda un mejor
O(n) rendimiento que el método
de inserción este más rápido
para el ordenamiento de
datos.
las isla, dividiéndola en dos sub-
En el caso óptimo, con los datos Con los datos ya ordenados, En terminos de n, el tamaño de
listas de igual tamaño. En este
ya ordenados, el algoritmo solo El mejor caso tiene definición análoga el algoritmo sólo la lista o arreglo. Para esto se
caso, el orden de complejidad del
O(n log n) efectuará n comparaciones, por a la de peor caso. effectura n comparaciones. O(n) usa el concepto de orden de
algoritmo es: O(n-logn), el
lo tanto la complejidad en el Por lo tanto la complejidad una funcion y se usa la
comportamiento en el mejor de los
caso óptimo es en O(n). en el caso óptimo es en Θ(n). notacion O(n).
casos ocurre cuando en cada paso
de la recursión en la partición

Shell modifico los saltos
continuos resultantes de las
comparaciones por saltos de
Caso pro med io O(n)
mayor tamaño y con eso se
conseguía la clasificación
más rápida
El pivote siempre se inclina hacia El término que crece más
Caso promedio: la idea es obtener el un lado, es decir, genera un arreglo rápido es el término Uso de memoria y otros
En el caso medio, la valor esperado para el tiempo.
de solo un elemento y una segunda cuadrático, por lo que se dice recursos computacionales.
O( n log n) complejidad de este algoritmo es Normalmente se obtiene suponiendo O(n^2)
con el resto de los elementos con que el ordenamiento por También se usa la notación
también en O(n^2). todas las entradas posibles con igual
su complejidad de O(n^2) inserción tiene una O(n).
probabilidad. complejidad de O(n^2).

El orden de complejidad del

La implementación de este Peor caso de tiempo de ejecución es algoritmo es O(n*log*n), esto se
método se puede hacer algo el límite superior para el tiempo de
En el caso desfavorable, con los debe por que la profundidad de
confusa, ya que este método ejecución considerando cualquier Es que la entrada estuviera Si el vector esta ordenado en
Peo r caso O(n) O(n log n) datos ordenados a la inversa, la recursión es log(n). O(n^2)
realiza numerosas entrada. El algoritmo no supera este ordenada en orden inverso orden inverso O(i(n)) = ?
complejidad es en O(n^2). Se produce cuando el pivote se
comparaciones e valor en ningún caso. inclina mas hacia un lado y los dos
intercambios.
sub-arreglos tienen distintos

package radixlsort;
public class metodos {
public int[] LlenarA (int
numero){
int arreglo[]= new
int[numero];
int i;
//Ingresando valores al
arreglo
Ejemplo
for (
i=0;i<arreglo.length;i++){
arreglo[i]=(int)(Math.random()*
9999999);//Genera numeros
aleatorios entre 0 y 1000000
for(int j=0;j<i; j++){
if(arreglo[i]==arreglo[j]){//se
utilizara para comparar que no
existan numeros repetidos
void shellsort(int vector [], package heapsortcr;
int tamaño
{ public class metodosHeap {
int salto;
int cambios; public int[] LlenarA (int
int post; numero){
int aux; int arreglo[]= new
salto= tamaño/2; int[numero];
do int i;
{ //Ingresando valores al
do arreglo
{ for (
i=0;i<arreglo.length;i++){
cambios = 0;
for (pos=salto; pos <
tamaño;pos++) arreglo[i]=(int)(Math.random()*
9999999);//Genera numeros
{ array[i] = array[i+1];
aleatorios entre 0 y 1000000
for(int j=0;j<i; j++){
if(arreglo[i]==arreglo[j]){//se
utilizara para comparar que no
existan numeros repetidos
dentro de los numeros random
public void Cocktelsort( int[] public void ordenacionMergeSort(int public void quicksort(int public class MetOrdenaInser class MetOrdenSelec { public class MetBurbuja {
array ){ arreglo[]){ arreglo[],int low,int high){ {
long public static void
inicio=System.nanoTime(); if(arreglo.length<=1) int middle=low+(high-low)/2; ordenar(int[] arreglo){ public static void
boolean intercambio; return; int pivote=arreglo[middle]; public static void int cont;//solo util para main(String[] args) {
do { int mitad= arreglo.length/2; int x=low,y=high; main(String[] args) { contar las comparaciones
intercambio = false; int cont = 1; int x
for (int i =0; i<= izq[]=Arrays.copyOfRange(arreglo, while(x<=y){ JOptionPane.showMessageDi =Integer.parseInt(JOptionPane
array.length - 2;i++) { 0, mitad); while(arreglo[x]<pivote){ alog(null, "MÉTODO DE for (int i = 0; i < .showInputDialog("Ingrese el
if (array[ i ] > array[ i + 1 ]) int x++; ORDENAMIENTO POR arreglo.length - 1; i++){ número de estudiantes"));
{ der[]=Arrays.copyOfRange(arreglo, } INSERCIÓN" ); int min = i;
// prueba si los dos mitad, arreglo.length); while(arreglo[y]>pivote){ int vct[] = new int[10]; for (int j = i + 1; j < int notas[]= new int[x];
ordenacionMergeSort(izq); y--; for(int i=0;i < arreglo.length; j++){ String estudiante[]= new
elementos están en el orden
ordenacionMergeSort(der); } vct.length;i++){ String[x];
incorrecto
int temp = array[i]; combinarVector(arreglo, if(x<=y){ cont++;
izq, der); int temp=arreglo[x]; if (arreglo[j] < for(int i =0;i < x;i++){
} arreglo[x]=arreglo[y]; vct[i] = arreglo[min]){ estudiante[i]=
array[i+1]=temp;
intercambio = true; arreglo[y]=temp; Integer.parseInt(JOptionPane min = j; JOptionPane.showInputDialog
} public void combinarVector(int x++; .showInputDialog((i+1)+ "º } ("Ingrese nombre y apellido
} v[], int izq[],int der[]){ y--; Numero :")); } del estudiante" );
if (!intercambio) { int i=0; } if (i != min){ notas[i]=
// Podemos salir del bucle int j=0; } String CAD int aux= arreglo[i]; Integer.parseInt(JOptionPane.s
externo aquÃ- si no se producen for(int } ="NÚMEROS SIN arreglo[i] = howInputDialog("Ingrese la