El ordenamiento de burbuja bidireccional (cocktail sort en inglés) es un algoritmo de ordenamiento que surge como una mejora del algoritmo ordenamiento de burbuja.

La manera de trabajar de este algoritmo es ir ordenando al mismo tiempo por los dos extremos del vector. De manera que tras la primera iteración, tanto el menor como el mayor elemento estarán en sus posiciones finales. De esta manera se reduce el número de comparaciones aunque la blod del algoritmo sigue siendo O(n²).

Fuente Wikipedia ^^^^^^

A continuación se muestra el código del algoritmo:

Desde mi punto de vista personal prefiero el sencillo ordenamiento burbuja.

/*
* CocktailSort.java
*
* Created on 5 de marzo de 2008, 09:38 PM
*/
/**
*
* @author p3ll3
*/

public class CocktailSort {

 //variables para ordenamiento
public static int izquierda,derecha,ultimo;
 // predefino arreglo
 public static int arreglo[] = {10,23,6,4,223,2,112,3,6,34};

public static void main(String[] args) {
 izquierda = 1;
 derecha = arreglo.length;
 ultimo = arreglo.length-1;

do{ 
 for(int i = arreglo.length-1;i > 0;i--){

//Burbuja hacia la izquierda
//Los valores menores van a la izquierda 
 if(arreglo[i-1] > arreglo[i]){
   int aux = arreglo[i]; // variable auxiliar para poder hacer
                                //intercambio de
   arreglo[i] = arreglo[i-1];  // posicion
   arreglo[i-1] = aux;
   ultimo = i;

  }    
 }
  izquierda = ultimo+1;
 for(int j=1;j <= arreglo.length-1;j++){

   if(arreglo[j-1] > arreglo[j]){
      int aux = arreglo[j];
      arreglo[j] = arreglo[j-1];
      arreglo[j-1] = aux;
     ultimo = j;
   } 

    } 
    derecha = ultimo-1;

  }while(derecha >= izquierda);

    for(int i=0;i <= arreglo.length-1;i++){ 
      System.out.println(arreglo[i]);
    }
 }
}

Espero que les  sirva , ahi me cuentan...

Ordenamiento Quicksort

Antes que nada aclararles que este es un ordenamiento recursivo y uno de los mas efectivos para ordenar.

   // @parametros : arreglo,indice inicio,indice final
  static void sort(int a[], int lo0, int hi0) {
    
    int lo = lo0;  
    int hi = hi0;
    
    if (lo >= hi) {
        return;
    }
    int mid = a[(lo + hi) / 2];
    while (lo < hi) {
        while (lo<hi && a[lo] < mid) {
            lo++;
        }
        while (lo<hi && a[hi] >= mid) {
            hi--;
        }
        if (lo < hi) {
            int T = a[lo];
            a[lo] = a[hi];
            a[hi] = T;
        }
    }
    if (hi < lo) {
        int T = hi;
        hi = lo;
        lo = T;
    }
    sort(a, lo0, lo);
    sort(a, lo == lo0 ? lo+1 : lo, hi0);
}

static void sort(int a[]) {
    sort(a, 0, a.length-1);
}

Ordenamiento Insercion

public static void Insercion(int [] arr){
       
 for (int i=1;i < arr.length;i++){
     
      int j=i;      
      int aux = arr[j];

   while( (j > 0) && (aux < arr[j-1]) ){
 
     arr[j] = arr[j-1];
     j--;
   }

   arr[j] = aux;
 }
}

Ordenamiento Seleccion

public static void Seleccion(int [] arr){
 
  int i;

  for (i=0; i < arr.length;i++){

    int temp=i;

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

       if(arr[i] > arr[j]){

         temp=j;

       }
    }
       if( i != temp){

         int cambio = arr[i];
         arr[i] = arr[temp];
         arr[temp] = cambio;
 
       }
   }
}

Ordenamiento Intercambio

public static void Intercambio(int [] arr){

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

        if (arr[i] > arr[j]){

          int temp = arr[j];
          arr[j] = arr[i];
          arr[i] = temp;

        }

    }
   }
}

Ordenamiento Burbuja

public void Burbuja(int [] arr){

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

       if(arr[i] > arr[j]){

         int temp = arr[i];
         arr[i] = arr[j];
         arr[j] = temp;

       }
    }
   }
}