QuickSort
規範事例：
尾が空である場合、それが注文されていると考えることができ、何もせずにすぐに戻るようにします。
再帰的な呼びかけ：
最初の尾から要素を削除します。この要素はピボットと見なされます。
2つの新しい空のキューを作成します。最初の尾は、ピボットよりも小さい要素を保存するために使用されます。
最初の尾に1つずつ残っている要素を抽出します。ピボットよりも低い要素は、未成年者の尾の端にそれらを追加します。等しくない要素は、それらを古い尾または等しい尾に置きます。
最初の尾は空になりましたが、その要素は、ピボット変数、ピボットよりも低い要素のある尾と、ピボットよりも大きいまたは等しい要素を持つ尾の尾に保存されます。
未成年者の尾を再帰的に注文してください。このテールには初期尾よりも少ない要素が含まれているため、この問題は最初の問題よりも必然的に簡単です。
より大きいまたは等しい尾を注文します。この尾にはピボットが含まれていないため、最初の尾よりも小さいです。
最初のキューに移動します：未成年者の尾の要素、ピボット、および高齢者の尾の要素は、その順序で。
今、最初の尾が注文されます！
この戦略を実装するプログラムは次のとおりです。

  void QuickSort（キューキュー）{
    // 規範事例
    if（tail.isempty（））
      戻る;
    //再帰的なケース
    int pivot = tail.geint（）;//尾は空ではありません
    キューマイナー= new Queue（）;// xより未成年者向けの尾
    キューエルダー= new Queue（）;// xよりも高齢者向けの尾
    //パーティション化
    while（！cola.isempti（））{
      int x = tail.geint（）;
      if（x> pivot）
        older.put（x）;
      それ以外
        minors.put（x）;
    }
    QuickSort（未成年者）;//未成年者は再帰的に注文されます
    QuickSort（古い）;//最大の再帰的な注文
    //値は最初の尾に返されます
    while（！minors.isemptia（））
      tail.put（minors.getint（））;
    Tail.put（pivot）;
    その間 （！
      cola.put（holdly.geint（））;
  }


バブルアルゴリズム
選択と交換の計画アルゴリズムは、不便を提示します。時間をかけて（n^2）アレンジメントが注文された場合でも。次のアルゴリズムはその側面を改善します。
アイデアは、無秩序な隣接する要素を交換することにより、アレンジメントでいくつかの連続したツアーを行うことです。次の図に示されているように、最初の反復では、最大値が配置の終了時にその決定的な位置に移動します。
2番目の反復では、2番目の格言が最終的な位置に移動します。そして、引き続きアレンジ全体を注文します。シーケンシャルルートで要素が交換されない場合、配置が順序付けられ、完了することができることに注意してください。コードは次のとおりです。


  void bubble（int [] a、int n）{
    int iult = n-1;
    ブール変更= true;
    while（change）{
      変更= false;
      for（int i = 0; i <iult; i ++）{
        if（a [i]> a [i+1]）{
          //交換します
          intまたは[i];
          a [i] = a [i+1];
          [R＆D 1] = aux;
          変更= true;
        }
      }
      iult--;
    }
  }

選択注文
その操作は次のとおりです。
リストの最小要素を見つけます
最初のものと交換します
リストの残りの部分で次の最小値を探してください
2番目と交換します
そして一般的に：
ポジションIとリストの終了の間の最小要素を見つける
位置iの要素と最小値を交換します
このようにして、次のpseudocodeを書き、0からインデックス付けされたn要素のリストを注文できます。
for（int i = 0; i <n-1; i ++）{
      int最小= i;
      for（int j = i+1; j <n; j ++）{
            if（list [j] <list [minimum]）{
                  最小= j;
            }
      }
      Exchange（list、i、minimal）;
}
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);
}