Está en la página 1de 9

import java.util.

Scanner;
public class MetodoIntercambio {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
System.out.print("Ingrese la longitud del arreglo: ");
int kevin = entrada.nextInt();
int arreglo[] = new int[kevin];
for (int i = 0; i < arreglo.length; i++) {
System.out.print("Ingrese: ");
arreglo[i]= entrada.nextInt();
}
ordIntercambiar(arreglo);
}

public static void intercambiar(int []a, int i, int j){


int aux = a[i];
a[i] = a[j];
a[j] = aux;
}
public static void ordIntercambiar(int a[]){
int i, j;
for(i=0; i<a.length-1; i++){
for (j = i+1; j < a.length; j++) {
if(a[i]>a[j]){
intercambiar(a,i,j);
}
}
}
System.out.println("\nORDENAMIENTO POR INTERCAMBIO...");
for (int k = 0; k < a.length; k++) {
System.out.print(a[k]+"\t");
}
}
}

import java.util.Scanner;

public class MetodoInsercionDirecta {


public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
System.out.print("Ingrese la longitud del arreglo: ");
int kevin = entrada.nextInt();
int arreglo[] = new int [kevin];
for (int i = 0; i < arreglo.length; i++) {
System.out.print("Ingrese: ");
arreglo[i] = entrada.nextInt();
}
ordInsercion(arreglo);
}
public static void ordInsercion(int []a){
int i, j;
int aux;
for (i = 1; i < a.length; i++) {
j=i;
aux=a[i];
while(j>0 && aux <a[j-1]){
a[j]= a[j-1];
j--;
}
a[j] = aux;
}
System.out.println("\nORDENAMIENTO POR INSERCION DIRECTA...");
for (int k = 0; k < a.length; k++) {
System.out.print(a[k]+"\t");
}
}
}

import java.util.Scanner;
public class MetodoSeleccionDirecta {
public static void main(String[] args) {
Scanner entrada = new Scanner (System.in);
System.out.print("Ingrese la longitud del arreglo: ");
int kevin = entrada.nextInt();
double arreglo[] = new double[kevin];
for (int i = 0; i < arreglo.length; i++) {
System.out.print("Ingrese: ");
arreglo[i]= entrada.nextDouble();
}
ordSeleccion(arreglo);
}
public static void ordSeleccion(double a[]){
int indiceMenor, i, j, n;
n = a.length;
for (i = 0; i < n-1; i++) {
indiceMenor = i;
for (j = i+1; j<n; j++) {
if(a[j] < a[indiceMenor])
indiceMenor=j;
if(i != indiceMenor){
a = intercambiar(a, i, indiceMenor);
indiceMenor = i;
}
}
}
System.out.println("\nORDENAMIENTO POR SELECCION DIRECTA...");
for (int k = 0; k < n; k++) {
System.out.print(a[k]+"\t");
}
}
public static double[] intercambiar(double a[], int i, int j){
double aux = a[i];
a[i] = a[j];
a[j] = aux;
return a;
}
}

import java.util.Scanner;
public class MetodoShellSort {
public static void main(String[] args) {
Scanner entrada = new Scanner (System.in);
System.out.print("Ingrese la longitud del arreglo : ");
int kevin = entrada.nextInt();
int arreglo[] = new int[kevin];
for (int i = 0; i < arreglo.length; i++) {
System.out.print("Ingrese numero: ");
arreglo[i] = entrada.nextInt();
}
shellSort(arreglo);
}
public static void shellSort(int a[]) {
for( int gap = a.length / 2; gap > 0; gap = gap == 2 ? 1 : (int) ( gap / 2.2 ) ){
for( int i = gap; i < a.length; i++ ){
int tmp = a[ i ];
int j;
for(j = i; j >= gap && tmp < a[ j - gap ] ; j -= gap ){
a[ j ] = a[ j - gap ];
}
a[ j ] = tmp;
}
}
System.out.println("\nORDENAMIENTO POR SHELL SORT...");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+"\t");
}
}
}

import java.util.Scanner;
public class MetodoQuickSort {
public static void main(String[] args) {
Scanner kc = new Scanner(System.in);
System.out.print("Ingrese la longitud del arreglo: ");
int kevin = kc.nextInt();
int arreglo[] = new int[kevin];
for (int i = 0; i < arreglo.length; i++) {
System.out.print("Ingrese numero: ");
arreglo[i] = kc.nextInt();
}
Quicksort(arreglo, 0, kevin - 1);
System.out.print("\nArreglo ordenado: ");
for(int i = 0; i < kevin; i++)
System.out.print(arreglo[i] + " ");
}
public static void Quicksort(int arr[], int p, int r){
if(p < r){
int q = Intercambio(arr, p, r);
Quicksort(arr, p, q - 1);
Quicksort(arr, q + 1, r);
}
}
public static int Intercambio(int arr[], int p, int r) {
int x = arr[r];
int i = p - 1, t;
for(int j = p; j < r; j++){
if(arr[j] <= x){
i++;
t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
t = arr[i + 1];
arr[i + 1] = arr[r];
arr[r] = t;
return i + 1;
}
}

La ordenacin o clasificacin de datos (sort, en ingls) es una operacin consistente en disponer un conjunto
estructura de datos en algn determinado orden con respecto a uno de los campos de los elementos del conjunto.
Una coleccin de datos (estructura) puede ser almacenada en memoria central o en archivos de datos externos
guardados en unidades de almacenamiento magntico (discos, cintas, CD-ROM, DVD, etc.).
Cuando los datos se guardan en un array, en una lista enlazada o en un rbol, se denomina ordenacin interna; estos
datos se almacenan exclusivamente para tratamientos internos que se utilizan para gestin masiva de datos, se guardan
en arrays de una o varias dimensiones. Si los datos estn almacenados en un archivo, el proceso de ordenacin se llama
ordenacin externa.
Los mtodos (algoritmos) de ordenacin son numerosos, por ello se debe prestar especial atencin en su eleccin. Cmo
se sabe cul es el mejor algoritmo? La eficiencia es el factor que mide la calidad y el rendimiento de un algoritmo. En el
caso de la operacin de ordenacin, se suelen seguir dos criterios a la hora de decidir qu algoritmo de entre los que
resuelven la ordenacin es el ms eficiente: 1) tiempo menor de ejecucin en computadora; 2) menor nmero de
instrucciones.
Los mtodos de ordenacin se suelen dividir en dos grandes grupos:
Directos burbuja, seleccin, insercin (para listas pequeas)
Indirectos (avanzados) shell, ordenacin rpida, ordenacin por mezcla (listas de mayor nmero de elementos)
ORDENAMIENTO POR INTERCAMBIO (BURBUJA)
El algoritmo de ordenacin tal vez ms sencillo sea el denominado de intercambio, que ordena los elementos de una lista
en orden ascendente. El algoritmo se basa en la lectura sucesiva de la lista a ordenar, comparando el elemento inferior de
la lista con los restantes y efectuando un intercambio de posiciones cuando el orden resultante de la comparacin no sea
el correcto.
En cada comparacin se comprueba si el elemento siguiente es ms pequeo que el elemento de ndice 0 y en ese caso,
se intercambian. Despus de terminar todas las comparaciones, el elemento ms pequeo se sita en el ndice 0., luego
seguimos el mismo procedimiento con la siguiente posicin.
ORDENAMIENTO POR INSERCION DIRECTA
El mtodo de ordenacin por insercin es similar al proceso tpico de ordenar tarjetas de nombres (cartas de una baraja)
por orden alfabtico consistente en insertar un nombre en su posicin correcta dentro de una lista que ya est ordenada.

El algoritmo correspondiente a la ordenacin por insercin contempla los siguientes pasos:


1. El primer elemento a[0] se considera ordenado; es decir, la lista inicial consta de un elemento.
2. Se inserta a[1] en la posicin correcta; delante o detrs de a[0], dependiendo de si es menor o mayor.
Por cada bucle o iteracin i (desde i=1 hasta n-1) se explora la sublista a[i-1] ...a[0] buscando la posicin correcta
de insercin de a[i]; a la vez, se mueven hacia abajo (a la derecha en la sublista) una posicin todos los
elementos mayores que el elemento a insertar a[i], para dejar vaca esa posicin.
4. Insertar el elemento a[i] a la posicin correcta.
La codificacin del algoritmo se realiza en el mtodo ordInsercion(). Se pasa como argumento el array, a[], que
se va a ordenar de modo creciente; el nmero de elementos a ordenar coincide con el atributo del array length.
Los elementos del array son de tipo entero; en realidad, pueden ser de cualquier tipo bsico y ordinal de Java.
A la hora de analizar este algoritmo, se observa que el nmero de instrucciones que realiza depende del bucle
automtico for (bucle externo) que anida al bucle condicional while. Siendo n el nmero de elementos (n ==

a.length), el bucle externo realiza n-1 pasadas; por cada una de ellas y en el peor de los casos (aux siempre menor
que a[j-1]), el bucle interno while itera un nmero creciente de veces que da lugar a la sucesin 1, 2, 3, ... n-1 (para i
== n-1). La suma de los trminos de la sucesin se ha obtenido y se ha comprobado que el trmino dominante es n2.
Como conclusin, la complejidad del algoritmo de insercin es 0(n2).
ORDENAMIENTO POR SELECCIN DIRECTA
Consiste en buscar el menor elemento del arreglo y colocarlo en la primera posicin.
Luego se busca el segundo elemento ms pequeo del arreglo y se coloca en la segunda posicin.
El proceso continua hasta que todos los elementos del arreglo han sido ordenados.

El mtodo ordSeleccion() ordena un array de nmeros reales de n elementos, n coincide con el atributo length del array.
En la pasada i, el proceso de seleccin explora la sublista a[i] a a[n-1] y fija el ndice del elemento ms pequeo. Despus
de terminar la exploracin, los elementos a[i] y a[indiceMenor] se intercambian; operacin que se realiza llamando al
mtodo intercambiar().
ORDENAMIENTO POR SHELL
La ordenacin Shell debe el nombre a su inventor, D. L. Shell. Se suele denominar tambin ordenacin por
insercin con incrementos decrecientes. Se considera que el mtodo Shell es una mejora del mtodo de insercin
directa.
En el algoritmo de insercin, cada elemento se compara con los elementos contiguos de su izquierda, uno tras
otro. Si el elemento a insertar es el ms pequeo, hay que realizar muchas comparaciones antes de colocarlo en
su lugar definitivo.
El algoritmo de Shell modifica los saltos contiguos resultantes de las comparaciones por saltos de mayor tamao,
y con ello se consigue que la ordenacin sea ms rpida. Generalmente, se toma como salto inicial n/2 (siendo n
el nmero de elementos), y luego se reduce el salto a la mitad en cada repeticin hasta que sea de tamao 1.
74, 14, 21, 44, 38, 97, 11, 78, 65, 88, 30
En nuestro ejemplo, n=11 (porque hay 11 elementos). As que k=n/2=11/2=5
Empezamos con k=5. As pues, vamos a dividir nuestro arreglo original en 5 sub-arreglo, en los cuales, sus elementos
estarn separados por 5 lugares del arreglo original (el salto o gap es 5).

RECURSIVIDAD
Un mtodo recursivo es aquel que se llama a s mismo, bien directamente o bien indirectamente, a travs de otro
mtodo. La recursividad es un tpico importante examinado frecuentemente en cursos que estudian la resolucin de
algoritmos y en cursos relativos a estructuras de datos.
Un enfoque recursivo se elige, normalmente, con preferencia a un enfoque iterativo cuando resulta ms natural para la
resolucin del problema y produce un programa ms fcil de comprender y de depurar. Otra razn para elegir una
solucin recursiva es que una solucin iterativa puede no ser clara ni evidente.
ORDENAMIENTO QUICKSORT
El algoritmo conocido como quicksort (ordenacin rpida) recibe su nombre de su autor, Tony Hoare. La idea del
algoritmo es simple, se basa en la divisin en particiones de la lista a ordenar, por ello se puede considerar que aplica la
tcnica "divide y vencers". El mtodo es, posiblemente, el ms pequeo de cdigo, ms rpido, ms elegante y ms
interesante y eficiente de los algoritmos conocidos de ordenacin.

Este mtodo se basa en dividir los n elementos de la lista a ordenar en dos partes o particiones separadas por un
elemento: una particin izquierda, un elemento central denominado pivote o elemento de particin y una particin
derecha. La particin o divisin se hace de tal forma que todos los elementos de la primera sublista (particin izquierda)
sean menores que todos los elementos de la segunda sublista (particin derecha). Las dos sublistas se ordenan entonces
independientemente.
Para dividir la lista en particiones (sublistas) se elige uno de los elementos de la lista y se utiliza como pivote o elemento
de particin. Si se elige una lista cualquiera con los elementos en orden aleatorio, se puede elegir cualquier elemento de
la lista como pivote, por ejemplo, el primer elemento de la lista. Si la lista tiene algn orden parcial que se conoce, se
puede tomar otra decisin para escogerlo. Idealmente, el pivote se debe elegir de modo que se divida la lista
exactamente por la mitad de acuerdo al tamao relativo de las claves. Por ejemplo, si se tiene una lista de enteros de 1 a
10, 5 o 6 seran pivotes ideales, mientras que 1 o 10 seran elecciones pobres de pivotes.
Una vez que el pivote ha sido elegido, se utiliza para ordenar el resto de la lista en dos sublistas: una tiene todas las claves
menores que el pivote y la otra, todos los elementos (claves) mayores o iguales que el pivote (o al revs). Estas dos listas
parciales se ordenan recursivamente utilizando el mismo algoritmo; es decir, se llama sucesivamente al propio algoritmo
quicksort.
La lista final ordenada se consigue concatenando la primera sublista, el pivote y la segunda lista, en ese orden, en una
nica lista. La primera etapa de quicksort es la divisin o particionado recursivo de la lista hasta que todas las sublistas
constan de slo un elemento.

ORDE
NAMI
ENTO
MERG
ESORT
Este ordenamiento fue desarrollado en 1945 por John Von
Neumann.
Merge sort es un ordenamiento estable, paraleliza mejor, y es
ms eficiente manejando medios secuenciales de acceso lento.
El algoritmo de ordenamiento por mezcla (merge sort) es
un algoritmo de ordenamiento externo estable basado en la
tcnica divide y vencers. Es a menudo la mejor opcin para
ordenar una lista enlazada.
Conceptualmente, el ordenamiento por mezcla funciona de la
siguiente manera:
Si la longitud de la lista es 0 1, entonces ya est ordenada. En otro caso:
Dividir la lista desordenada en dos sublistas de aproximadamente la mitad del tamao.
Ordenar cada sublista recursivamente aplicando el ordenamiento por mezcla.
Mezclar las dos sublistas en una sola lista ordenada.
Lo que hace este mtodo, es dividir en 2 partes el arreglo, despus en otras 2 y as hasta tener los elementos separados.
Comparamos los elementos y escribimos el menor. Volvemos a comparar y as hasta tener nuestro arreglo acomodado.

La eficiencia de este algoritmo es bastante notable en tiempo de ejecucin en comparacin con otros, ya que su manera
de trabajo por grupos pequeos agiliza la organizacin de los datos. Su utilizacin se da con mucha frecuencia cuando
la cantidad de registros no es muy grande ya que para hacer las mezclas ste mtodo utiliza el doble del espacio que
gasta el arreglo original de valores.
Este es un algoritmo estable (no intercambia los registros con claves iguales) dependiendo de la forma en que se
implemente, recursivo y por tanto de complejidad O(n log2n) tanto en el peor caso como en el mejor o en el
caso promedio pues el tiempo que emplea no depende de la disposicin inicial de los datos.

También podría gustarte