Algunos Algoritmos De Ordenamiento

Algoritmo de ordenamiento
En computación y matemáticas un algoritmo de ordenamiento es un algoritmo que pone elementos de una lista o un vector en una secuencia dada por una relación de orden, es decir, el resultado de salida ha de ser una permutación —o reordenamiento— de la entrada que satisfaga la relación de orden dada. 
Los 3 Métodos de Ordenamiento más populares son:
1) Bubble Sort(Ordenamiento Burbuja):
Es el algoritmo de ordenamiento más sencillo de todos, conocido también como método del intercambio directo, el funcionamiento se basa en la revisión de cada elemento de la lista que va a ser ordenada con el elemento siguiente, intercambiando sus posiciones si están en el orden equivocado, para esto se requieren varias revisiones hasta que ya no se necesiten más intercambios,lo que indica que la lista ha sido ordenada.
El origen del nombre de este algoritmo proviene de la forma con la que suben por la lista los elementos durante los intercambios, tal y como si fueran "burbujas", el algoritmo fundamental de este método es la simple comparación de elementos siendo así el más fácil de implementar.

Codificación en Java:
public static int[] OrdenarBurbuja(int[] n)
{int temp;
int t = n.length;
for (int i = 1; i < t; i++) 
{
for (int k = t- 1; k >= i; k--) 
{
if(n[k] < n[k-1])
{
temp = n[k];
n[k] = n[k-1];
n[k-1]= temp;
}
}
}
return n;
}

Codificación en C#:
Public int[]OrdenarBurbuja(int[]x)
{
int t= x.Length, temp;
for(int i=1 ; i< t ; i++)
{
  for(int j = t-1 ; j >= i; j--)
  {
    if(x[j] < x[j-1])
    {
      temp= x[j];
      x[j]= x[j-1];
      x[j-1]= temp;
   }
  }
}
}
Ejemplo del ordenamiento de burbuja ordenando una lista de números aleatorios.

Animacion Bubble Sort
2) Quick Sort (Ordenamiento Rápido):
Es el algoritmo de ordenamiento más eficiente de todos, se basa en la técnica de "Divide y Vencerás", que permite en promedio, ordenar n elementos en un tiempo proporcional a n*log(n).
Algoritmo Fundamental:1. Elegir un elemento de la lista de elementos a ordenar, al que llamaremos pivote.
2. Resituar los demás elementos de la lista a cada lado del pivote, de manera que a un lado queden todos los menores que él, y al otro los mayores. Los elementos iguales al pivote pueden ser colocados tanto a su derecha como a su izquierda, dependiendo de la implementación deseada. En este momento, el pivoteocupa exactamente el lugar que le corresponderá en la lista ordenada.
3. La lista queda separada en dos sublistas, una formada por los elementos a la izquierda del pivote, y otra por los elementos a su derecha.
4. Repetir este proceso de forma recursiva para cada sublista mientras éstas contengan más de un elemento. Una vez terminado este proceso todos los elementos estarán ordenados.Codificación en Java:
void Quicksort(int[] vector, int first, int last)
{
int i=first, j=last;
int pivote=vector[(first + last) / 2];
int auxiliar;

do
{
  while(vector[i]<pivote) i++;
  while(vector[j]>pivote) j--;
 
  if (i<=j)
  {
    auxiliar=vector[j];
     vector[j]=vector[i];
   vector[i]=auxiliar;
    i++;
    j--;
  }
}
while (i<=j);

if(first<j)
{
  Quicksort(vector,first, j);
}

if(last>i)
{
  Quicksort(vector,i, last);
}
}

Codificación en C#:
void Quicksort(int[] v, int prim, int ult)
{
if (prim < ult)
{
/*Selecciona 1 elemento del...