Codificado Método Burbuja en Java (Netbeans):

public class Burbuja {

public static void main(String[] args) {
Scanner numero=new Scanner(System.in);
int num;
System.out.print("Ingrese el numero de elementos para el vector: ");
num=numero.nextInt();
Scanner ordenar = new Scanner(System.in);
int vector[] = new int[30];
int i,j,aux;
for (i=0;i<num;i++)
{
System.out.print("Datos["+(i+1)+"]=");
vector[i]=ordenar.nextInt();
}
for (i=0;i<num;i++)
{
for (j=i+1;j<num;j++)
{
if (vector[i]>vector[j])
{
aux=vector[i];
vector[i]=vector[j];
vector[j]=aux;
}
}
}
System.out.print("Arreglo= {");
for (i=0;i<num;i++)
{
System.out.print(vector[i]+ ", ");
}
System.out.print("}");
}

2) Método de Ordenamiento Inserción

Consiste en ir insertando un elemento de la lista ó un arreglo en la parte ordenada de la misma,
asumiendo que el primer elemento es la parte ordenada, el algoritmo ira comparando un elemento de
la parte desordenada de la lista con los elementos de la parte ordenada, insertando el elemento en la
posición correcta dentro de la parte ordenada, y así sucesivamente hasta obtener la lista ordenada.
Codificado Método Inserción en Java (Netbeans):

public class Insercion {

public static void main(String[] args) {

Scanner numero= new Scanner(System.in);

int num;

System.out.print("Ingrese el numero de elementos para el vector: ");

num=numero.nextInt();

System.out.println("Ingrese los datos del vector");

Scanner ordenar = new Scanner(System.in);

int vector[] = new int[num];

int aux,x,y;

for (int i=0;i<num;i++)

System.out.print("A["+(i+1)+"]=");

vector[i]=ordenar.nextInt();

for (x=1 ; x < vector.length; x++)

aux = vector[x];

for (y = x-1; y >=0 && vector [y]>aux ; y --)

 {

vector[y+1] = vector [y];

vector [y] = aux;

System.out.println("El nuevo vector es: ");

System.out.print("Arreglo= {");

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

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

System.out.print("}");

3) Método de Ordenamiento por Selección

El método de ordenamiento por selección consiste en encontrar el menor de todos los elementos del
arreglo e intercambiarlo con el que esta en la primera posición.

Luego el segundo mas pequeño, y así sucesivamente hasta ordenar todo el arreglo.

Codificado Método Selección en Java (Netbeans):

public class Seleccion {

public static void main(String[] args) {

Scanner numero=new Scanner(System.in);

int num;

System.out.print("Ingrese el numero de elementos para el vector: ");

num=numero.nextInt();

int vector[] = new int[30];

int aux;

for (int i=0;i<num;i++)

{
System.out.print("Datos["+(i+1)+"]=");
vector[i]=numero.nextInt();
}
for (int i = 0; i < num - 1; i++)
{
int min = i;
for (int j = i + 1; j < num; j++)
{
if (vector[j] < vector[min])
{
min = j;
}
}
if (i != min)
{
aux= vector[i];
vector[i] = vector[min];
vector[min] = aux;
}
}
System.out.print("Arreglo= {");
for (int i=0;i<num;i++)
{
System.out.print(vector[i]+ ", ");
}
System.out.print("}");
}
}

4) Método de Ordenamiento por HeapSort

Este algoritmo consiste en almacenar todos los elementos del vector a ordenar en un
montículo (heap), y luego extraer el nodo que queda como nodo raíz del montículo (cima)
en sucesivas iteraciones obteniendo el conjunto ordenado. Basa su funcionamiento en una
propiedad de los montículos, por la cual, la cima contiene siempre el menor elemento (o el
mayor, según se haya definido el montículo) de todos los almacenados en él. El algoritmo,
después de cada extracción, recoloca en el nodo raíz o cima, la última hoja por la derecha
del último nivel. Lo cual destruye la propiedad heap del árbol. Pero, a continuación realiza
un proceso de "descenso" del número insertado de forma que se elige a cada movimiento
el mayor de sus dos hijos, con el que se intercambia. Este intercambio, realizado
sucesivamente "hunde" el nodo en el árbol restaurando la propiedad montículo del arbol y
dejándo paso a la siguiente extracción del nodo raíz.

Codificado Método HeapSort en Java (Netbeans): Programa Principal

public class HeapSort {

public static void main(String[] args) {
Scanner numero= new Scanner(System.in);
int num;
System.out.print("Ingrese la cantidad de posiciones que tendra el vector: ");
num=numero.nextInt();
System.out.println("Ingrese los datos del vector");

Scanner orderselec = new Scanner(System.in);

int vector[] = new int[num];

for (int i=0;i<num;i++)

{
System.out.print("A["+(i+1)+"]=");
vector[i]=orderselec.nextInt();
}

for(int i=num; i>1; i--)

{
Heap r=new Heap();
r.fnSortHeap(vector, i-1);
}
System.out.print("Arreglo= {");
for (int i=0;i<num;i++)
{
System.out.print(vector[i]+ ", ");
}
System.out.print("}");
}
}

5) Método de Ordenamiento Shell

El método Shell es una versión mejorada del método inserción directa. Este método también se
conoce con el nombre de inserción con incrementos decrecientes. Shell propone que las
comparaciones entre elementos se efectúen con saltos de mayor tamaño pero con incrementos
decrecientes, asi, los elementos quedaran ordenados en el arreglo mas rápidamente.
Codificado Método Shell en Java (Netbeans):

public class Shell {

public static void main(String[] args) {

Scanner numero=new Scanner(System.in);

int num;
System.out.print("Ingrese el numero de elementos para el vector: ");
num=numero.nextInt();
int vector[] = new int[30];
int aux;
for (int i=0;i<num;i++)
{
System.out.print("Datos["+(i+1)+"]=");
vector[i]=numero.nextInt();
}
for ( int increment = num / 2; increment > 0; increment =
(increment == 2 ? 1 : (int) Math.round(increment / 2.2)))
{
for (int i = increment; i < num; i++)
{
for (int j = i; j >= increment && vector[j - increment] >
vector[j]; j -= increment)
{
int temp = vector[j];
vector[j] = vector[j - increment];
vector[j - increment] = temp;
}
}
}
System.out.print("Arreglo= {");
for (int i=0;i<num;i++)
{
System.out.print(vector[i]+ ", ");
}
System.out.print("}");
}
}

6) Método de Ordenamiento Quick Sort

Este método es el más rápido gracias a sus llamadas recursivas, basándose en la teoría de divide y
vencerás.

Lo que hace este algoritmo es dividir recursivamente el vector en partes iguales, indicando un elemento
de inicio, fin y un pivote (o comodín) que nos permitirá segmentar nuestra lista. Una vez dividida, lo
que hace, es dejar todos los mayores que el pivote a su derecha y todos los menores a su izq. Al
finalizar el algoritmo, nuestros elementos están ordenados.

Codificado Método Quick Sort en Java (Netbeans): Programa Principal

public static void main(String[] args) {

System.out.println("El vector ingresado es 5, 8 ,6 ,3 ,9 ,45 ,76 ,9");
int vector1 []= {5, 8 ,6 ,3 ,9 ,45 ,76 ,9};

OrdenarQ o=new OrdenarQ();

o.ordenarquicksort(vector1);

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

{
System.out.println(vector1[i]);
}
}
}

Clase Quick Sort:

public class OrdenarQ {

public void ordenarquicksort(int [] vector2)
{
vector2 = quicksort1(vector2);
}
public int[] quicksort1 (int numeros[])
{
return quicksort2 (numeros,0,numeros.length -1);
}
public int[] quicksort2 (int numeros[],int izq, int der)
{
if (izq >= der)
return numeros;
int i=izq,d=der;
if(izq != der)
{
int pivote;
 int aux;
pivote= izq;
while (izq != der)
{
while (numeros [der] >= numeros [pivote] && izq < der)
der --;
while (numeros [izq] < numeros [pivote] && izq<der)
izq++;
if (der != izq)
{
aux=numeros [der];
numeros[der]= numeros [izq];
numeros[izq]= aux;
}

if (izq == der)
{
quicksort2 (numeros,1,izq-1);
quicksort2 (numeros,izq+1,d);
}
}
}
else
return numeros;
return numeros;
}
}