assistant: Quicksort
Caso base:
Si cola esta vacía, se puede considerar que está ordenada, de modo que se retorna de inmediato, sin hacer nada.
Invocaciones recursivas:
Extraiga un elemento de la cola inicial. Este elemento será considerado el pivote.
Construya dos nuevas colas vacías. La primera cola se usará para almacenar elementos menores que el pivote, la segunda para elementos mayores o iguales al pivote.
Extraiga uno a uno los elementos que quedan en la cola inicial. Los elementos que son menores que el pivote, agréguelos al final de la cola de menores. Los elementos que son mayores o iguales, colóquelos en la cola de los mayores o iguales.
Ahora la cola inicial está vacía, pero sus elementos están almacenado en: la variable pivote, la cola con los elementos menores que el pivote y la cola con los elementos mayores o iguales que el pivote.
Ordene recursivamente la cola de menores. Este problema es obligatoriamente más simple que el problema inicial, porque esta cola contiene menos elementos que la cola inicial.
Ordene recursivamente la cola de mayores o iguales. Esta cola no contiene el pivote, y por lo tanto es de menor tamaño que la cola inicial.
Transfiera a la cola inicial: los elementos de la cola de menores, el pivote y los elementos de la cola de mayores, en ese orden.
Ahora la cola inicial se encuentra ordenada!
El programa que implementa esta estrategia es el siguiente:

  void quicksort(Queue cola) {
    // Caso base
    if (cola.isEmpty())
      return;
    // Caso recursivo
    int pivot= cola.getInt(); // La cola no esta vacía
    Queue menores= new Queue(); // Una cola para los menores que x
    Queue mayores= new Queue(); // Una cola para los mayores que x
    // Particionamiento
    while (!cola.isEmpty()) {
      int x= cola.getInt();
      if (x>pivot)
        mayores.put(x);
      else
        menores.put(x);
    }
    quicksort(menores); // Se ordenan los menores recursivamente
    quicksort(mayores); // Se ordenan los mayores recursivamente
    // Se regresan los valores a la cola inicial
    while (!menores.isEmpty())
      cola.put(menores.getInt());
    cola.put(pivot);
    while (!mayores.isEmpty())
      cola.put(mayores.getInt());
  }


Algoritmo de la burbuja
El algoritmo de ordenamiento por selección y reemplazo presenta un incoveniente: toma tiempo O(n^2) aún cuando el arreglo esté ordenado. El siguiente algoritmo mejora ese aspecto.
La idea consiste en realizar varios recorridos secuenciales en el arreglo intercambiando los elementos adyacentes que estén desordenados. Como se muestra en la siguiente figura, en la primera iteración se lleva el máximo a su posición definitiva al final del arreglo:
En la segunda iteración se lleva el segundo máximo a su posición definitiva. Y así continúa hasta ordenar todo el arreglo. Observe que si en un recorrido secuencial no se intercambia ningún elemento, el arreglo está ordenado y se puede concluir. El código es entonces:


  void burbuja(int[ ] a, int n) {
    int iult= n-1;
    boolean cambio= true;
    while (cambio) {
      cambio= false;
      for (int i= 0; i<iult; i++) {
        if (a[i]>a[i+1]) {
          // intercambiar
          int aux= a[i];
          a[i]= a[i+1];
          a[i+1]= aux;
          cambio= true;
        }
      }
      iult--;
    }
  }

Ordenamiento por selección
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
De esta manera se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 0:
for(int i = 0; i < n-1 ; i++){
      int minimo = i;
      for(int j = i + 1 ; j < n ; j++){
            if(lista[j] < lista[minimo]){
                  minimo = j;
            }
      }
      intercambiar(lista , i , minimo);
}