ORDENAMIENTO EN TIEMPO LINEAL

Foro Semana 5 y 6

Integrantes:
Carlos Augusto Sabino Cañizares

Análisis y verificación de Algoritmos

2019
 TRABAJO

El trabajo a realizar debe hacerse en grupos de mínimo tres y máximo cuatro

participantes. El trabajo colaborativo es obligatorio, por lo que no se aceptarán
participaciones individuales. Únicamente uno de los participantes del grupo,
elegido por sus compañeros, publicará el reporte final de lo discutido por el
grupo. No obstante, todos pueden aportar en el foro dando su opinión sobre los
trabajos presentados por otros. Es importante que usen más de una fuente de
información.

El tema a discutir en el foro es “Algoritmos de ordenamiento en tiempo lineal”.

En particular, nos centraremos en los algoritmos Counting sort, Radix sort y
Bucket sort. Para cada uno de estos algoritmos deberán:

1. Dar una descripción breve pero completa del algoritmo. Preferiblemente,

debería proveerse pseudocódigo.

2. Implementar el algoritmo en alguno de los siguientes lenguajes de

programación: java, c, c++ o python.

3. Discutir cuándo el algoritmo es más adecuado que los algoritmos

basados en comparaciones (estudiados en las lecturas).

Finalmente, deberán realizar un cuadro comparativo de los tres algoritmos. Se

sugiere en este cuadro abordar aspectos como facilidad para comprender el
algoritmo, facilidad de implementación, restricciones sobre el conjunto de datos
a ordenar, entre otros.
 Counting sort
Es un algoritmo de ordenamiento en el que se cuenta el número de elementos de
cada clase para luego ordenarlos. Sólo puede ser utilizado por tanto para ordenar
elementos que sean contables (como los números enteros en un determinado
intervalo, pero no los números reales, por ejemplo). (Wikipedia)

Características:
Se trata de un algoritmo estable cuya complejidad computacional es O(n+k),
siendo n el número de elementos a ordenar y kel tamaño del vector auxiliar
(máximo - mínimo).
La eficiencia del algoritmo es independiente de lo casi ordenado que estuviera
anteriormente. Es decir no existe un mejor y peor caso, todos los casos se tratan
iguales.
El algoritmo counting, no se ordena in situ, sino que requiere de una memoria
adicional.

Limitaciones:
Sólo puede ser utilizado en determinadas circunstancias.
Sólo ordena números enteros, no vale para ordenar cadenas y es desaconsejable
para ordenar números decimales.
Otra limitación (por ineficiencia) incluso con números enteros es cuando el rango
entre el mayor y el menor es muy grande.
El pseudocódigo sería el siguiente:
Ordenamiento_por_Cuenta( A, B, k )
1 for i <-- 1 to k
2 do C[i] <-- 0
3 for j <-- 1 to tamaño[A]
4 do C[ A[j] ] <-- C[ A[j] ] + 1
5 // C[i] contiene ahora el número de elementos igual a 'i'
6 for i <-- 2 to k
7 do C[i] <-- C[i] + C[i-1]
8 // C[i] contiene ahora el número de elementos menor que o igual a 'i'
9 for j <-- tamaño[A] downto 1
10 do B[ C[ A[j] ] ] <-- A[j]
11 C[ A[j] ] <-- C[ A[j] ] - 1
Veamos:

- No está presente sentencia alguna IF en el algoritmo (sin condiciones, a

excepción de los bucles. Para su mejor funcionamiento debemos utilizarlo,
probarlo con muchos números, una lista larga de números de un solo
elemento simple: no hay structs (Los miembros de una estructura pueden
ser variables de los tipos de datos básicos (int, char, float, etc) o agregados
como ser arreglos y otras estructuras.), y de números repetitivos.
- Es mejor que los números no se separen mucho entre sí; por ejemplo, el
valor máximo sea de 10, y el mínimo de 1, aunque tengamos 10.000
entradas (o elementos). La desventaja de este algoritmo es la necesidad de
almacenar muchos datos en memoria. (Artículos con clase)

Simbología del Pseudocódigo:

Símbolo Significado
^

A Lista principal o de entrada

B Lista final u ordenada
Lista de contabilidad o de
C
frecuencia
k Valor máximo en A

Acerca del pseudocódigo

^

La Indentación o sangrado a la derecha es muy importante, pasos 10 y 11 son parte del

bucle for (paso 9).
Símbolo Significado
<-- Asignación.
1 to k Valores enteros "de 1 a k",
incrementando de 1 a 1.
5 downto1 Valores enteros "de 5 a 1",
restando de 1 en 1.
A[j] Acceso; igual que en C/C++
// Comentarios
Entendámoslo con un Ejemplo:

0. C es inicializada asignando todos elementos a cero (pasos 1-2).

1. Empezamos con una lista desordenada, A, de números enteros que se
repiten varias veces.
2. C es asignada valores que representan la cuenta de cada elemento
de A (pasos 3-4). El índice de C representa el elemento de A: 0 unos, 0
doses, 3 treses, y 2 cuatros.

Paso 1 Paso 2

1 2 3 4 5 1 2 3 4
3 4 4 3 3 0 0 3 2

3. C es asignada a cada elemento la suma de su valor y el del elemento

anterior (pasos 6-7); por ejemplo, C[3] = C[3] + C[2], etc. Esto sirve para
saber en qué índice acaba el bloque de números repetidos: C [3] = 3 =>
bloque de treses acaba en índice 3, C [4] = 5 => bloque de cuatros acaba
en índice 5.
4. B es la lista ordenada de A. Es asignada el primer número ordenada: 3
(pasos 9-10), con j = 5.

Paso 3 Paso 4

1 2 3 4 1 2 3 4 5
0 0 2 5 3

5. El elemento de C usado para ordenar B es restado 1 (paso 11).

6. B es añadida otro número en su propio sitio, con j = 3.

Paso 5 Paso 6

1 2 3 4 1 2 3 4 5
0 0 2 5 3 3

7. C es nuevamente restada 1 al elemento recién usado (paso 11).

8. B es añadida otro número en su propio sitio, con j = 3.
 Paso 7 Paso 8

1 2 3 4 1 2 3 4 5
0 0 1 5 3 3 4

9. Se repite paso 11.

10. Pasos 9-10, con j = 2.

Paso 9 Paso 10

1 2 3 4 1 2 3 4 5
0 0 1 4 3 3 4 4

11. Paso 11
12. Pasos 9-10, con j=1

Paso 11 Paso 12

1 2 3 4 1 2 3 4 5
0 0 1 3 3 3 3 4 4

13. Ningún elemento de C tendrá un valor negativo.

Paso 13

1 2 3 4
0 0 0 3
14. j = 0, por lo tanto se sale del bucle for. B da lugar al resultado, que es el
ordenamiento de A:

Paso 14

1 2 3 4 5
3 3 3 4 4
 Después que los datos de entrada han pasado por los diferentes ciclos de
este algoritmo. Finalizara cuando todos los valores de entrada estén en su
posición correspondiente.

CountingSort corriendo en Java:

Código fuente (CountingSort.java) (javacodex.com)

import java.util.*;

public class CountingSort{

public static int[] sort(int[] array) {

// array to be sorted in, this array is necessary

// when we sort object datatypes, if we don't,
// we can sort directly into the input array
int[] aux = new int[array.length];

// find the smallest and the largest value

int min = array[0];
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] < min) {
min = array[i];
 } else if (array[i] > max) {
max = array[i];
}
}

// init array of frequencies

int[] counts = new int[max - min + 1];

// init the frequencies

for (int i = 0; i < array.length; i++) {
counts[array[i] - min]++;
}

// recalculate the array - create the array of occurences

counts[0]--;
for (int i = 1; i < counts.length; i++) {
counts[i] = counts[i] + counts[i-1];
}

/*
Sort the array right to the left
1) Look up in the array of occurences the last occurence of the given
value
2) Place it into the sorted array
3) Decrement the index of the last occurence of the given value
4) Continue with the previous value of the input array (goto set1),
terminate if all values were already sorted
*/
for (int i = array.length - 1; i >= 0; i--) {
aux[counts[array[i] - min]--] = array[i];
}

return aux;
}

public static void main(String[] args) {

int [] unsorted = {5,3,0,2,4,1,0,5,2,3,1,4};

System.out.println("Before: " + Arrays.toString(unsorted));

int [] sorted = sort(unsorted);

System.out.println("After: " + Arrays.toString(sorted));

}
}
 Radixt sort
Radix Sort es uno de los algoritmos de clasificación lineal más eficientes y
rápidos. Es fácil de entender y fácil de implementar. Radix Sort es una buena
opción para muchos programas que necesitan una clasificación rápida.
Radix Sort puede manejar claves más grandes de manera más eficiente en
comparación con Counting Sort.

Radix Sort es un algoritmo de clasificación no comparativo con complejidad

asintótica O (nd) . Es uno de los algoritmos de clasificación lineal más rápidos y
eficientes. La clasificación de radix fue desarrollada para ordenar enteros
grandes. Como el número entero se trata como una cadena de dígitos, también
podemos llamarlo algoritmo de clasificación de cadenas. (CODINGEEK)

Radix-Sort(A, d)
//It works same as counting sort for d number of passes.
//Each key in A[1..n] is a d-digit integer.
//(Digits are numbered 1 to d from right to left.)
for j = 1 to d do
//A[]-- Initial Array to Sort
int count[10] = {0};
//Store the count of "keys" in count[]
//key- it is number at digit place j
for i = 0 to n do
count[key of(A[i]) in pass j]++

for k = 1 to 10 do
count[k] = count[k] + count[k-1]

//Build the resulting array by checking

//new position of A[i] from count[k]
for i = n-1 downto 0 do
result[ count[key of(A[i])] ] = A[j]
count[key of(A[i])]--

//Now main array A[] contains sorted numbers

//according to current digit place
for i=0 to n do
A[i] = result[i]

end for(j)
end func
  En la clasificación de radix, primero ordenamos los elementos según el último
dígito (el dígito menos significativo). Luego, el resultado se clasifica
nuevamente por segundo dígito, continúe este proceso para todos los dígitos
hasta que alcancemos el dígito más significativo. Usamos el orden de conteo
para ordenar los elementos de cada dígito, por lo que la complejidad del
tiempo es O (nd), donde ), donde n es el tamaño de la matriz y d es el número
de dígitos en el número más grande.

Aquí hay algunos puntos clave del algoritmo de clasificación de radix:

 Radix Sort es un algoritmo de clasificación lineal.

 La complejidad de tiempo de la clasificación de Radix es O (nd), donde n es el
tamaño de la matriz y d es el número de dígitos en el número más grande.
 No es un algoritmo de clasificación en el lugar , ya que requiere espacio
adicional adicional.
 Radix Sort es una ordenación estable ya que se mantiene el orden relativo de
los elementos con valores iguales.
 La clasificación por radix puede ser más lenta que otros algoritmos de
clasificación, como la clasificación por fusión y la clasificación rápida, si las
operaciones no son lo suficientemente eficientes. Estas operaciones incluyen
funciones de inserción y eliminación de la sub-lista y el proceso de aislamiento
de los dígitos que queremos.
1011

Entendámoslo con un Ejemplo:

En la imagen que se muestra a continuación tratemos de visualizar el

concepto de este algoritmo.
 En el ejemplo anterior:
Para la primera pasada: ordenamos la matriz en base al dígito menos
significativo (lugar 1s) usando la clasificación de conteo. Observe que
43 5 está por debajo de 83 5, porque 43 5 ocurrió por debajo de 83 5en la
lista original.
Para la 2ª pasada: ordenamos la matriz en función del siguiente dígito (lugar
10) utilizando la clasificación de conteo. Observe que aquí 6 0 8 está por
debajo de 7 0 4, porque 6 0 8 ocurrió por debajo de 7 0 4 en la lista anterior, y
de manera similar para (8 3 5, 4 3 5) y (7 5 1, 4 5 3).

Para la 3ª pasada: clasificamos la matriz según el dígito más significativo

(lugar 100) utilizando la clasificación de conteo. Observe que aquí 4 35 está
por debajo de 4 53, porque 4 35 ocurrió por debajo de 4 53 en la lista
anterior, y de manera similar para ( 6 08, 6 90) y ( 7 04, 7 51).

Es un algoritmo de ordenamiento que ordena enteros procesando sus dígitos de

forma individual

Radix Sort corriendo en Java:

 Código fuente (Radix Sort (GeerForGeeks)
// Radix sort Java implementation
import java.io.*;
import java.util.*;

class Radix {
// A utility function to get maximum value in arr[]
static int getMax(int arr[], int n)
{
int mx = arr[0];
for (int i = 1; i < n; i++)
if (arr[i] > mx)
mx = arr[i];
return mx;
}

static void countSort(int arr[], int n, int exp)

{
int output[] = new int[n]; // output array
int i;
int count[] = new int[10];
Arrays.fill(count,0);

for (i = 0; i < n; i++)

count[ (arr[i]/exp)%10 ]++;

for (i = 1; i < 10; i++)

count[i] += count[i - 1];

// Build the output array

for (i = n - 1; i >= 0; i--)
{
output[count[ (arr[i]/exp)%10 ] - 1] = arr[i];
count[ (arr[i]/exp)%10 ]--;
}

// Copy the output array to arr[], so that arr[] now

// contains sorted numbers according to curent digit
for (i = 0; i < n; i++)
arr[i] = output[i];
}

static void radixsort(int arr[], int n)

{
int m = getMax(arr, n);

// Do counting sort for every digit. Note that instead

// of passing digit number, exp is passed. exp is 10^i
// where i is current digit number
for (int exp = 1; m/exp > 0; exp *= 10)
countSort(arr, n, exp);
}
static void print(int arr[], int n)
{
 for (int i=0; i<n; i++)
System.out.print(arr[i]+" ");
}

public static void main (String[] args)

{
int arr[] = {170, 45, 75, 90, 802, 24, 2, 66};
int n = arr.length;
radixsort(arr, n);
print(arr, n);
}
} /* This code is contributed by Devesh Agrawal */

Bucket sort

La ordenación Bucket sort u ordenación de cubos o clasificación de

compartimientos, es un algoritmo de clasificación que funciona mediante la
distribución de los elementos de una matriz en una serie de compartimientos.
Sirve para dos cosas:

1. Para ordenar un conjunto de datos.

2. Para que los maestros puedan poner tareas.

Este algoritmo consiste en iterar sobre todo el conjunto de datos e ir añadiendo

esto datos a una serie de listas finitas que contendrán datos con un rango de
valores.
Cada una de estas listas tendrá un conjunto con datos que sera mas fácil
ordenarlos, por lo que las comparaciones necesarias se reducen drasticamente.

El algoritmo contiene los siguientes pasos:

1. Crear una colección de casilleros vacíos

2. Colocar cada elemento a ordenar en un único casillero
3. Ordenar individualmente cada casillero
4. devolver los elementos de cada casillero concatenados por orden
 El pseudocódigo sería el siguiente:

función bucket-sort(elementos, n)
casilleros ← colección de n listas
para i = 1 hasta longitud(elementos) hacer
c ← buscar el casillero adecuado
insertar elementos[i] en casillero[c]
fin para
para i = 1 hasta n hacer
ordenar(casilleros[i])
fin para
devolver la concatenación de casilleros[1],..., casilleros[n]

Aquí elementos es la lista de datos a ordenar y n el número de casilleros que

queremos usar. Para buscar el casillero adecuado para un elemento se puede
utilizar la técnica que más convenga, según cómo queramos ordenar los datos. La
función ordenar puede ser cualquier función de ordenamiento, incluso la
propia bucket-sort. (Wikipedia)

 Funciona con números en el intervalo [0..1).

 Se supone que la distribución de los números es uniforme.
 La idea es dividir el intervalo [0..1) en n subintervalos del mismo tamaño
(llamados buckets) y distribuir los n números en los buckets. Para producir
la salida, se ordenan los numeros de cada bucket y se mezclan los
elementos de todos los buckets.
En este sencillo ejemplo se procedera a visualizar el funcionamiento
del Bucket Sort. (Neocities Ordenamientos)

Se reciben tanto el arreglo (elementos en negro) como la cantidad de

buckets"(azul) y se determinan los intervalos para estos:

Se procede a llenar los "buckets" con los elementos que pertenezcan al intervalo:

En este segundo paso, otro método de ordenacion es aplicado a los "buckets"

ordenando sus elementos de forma más rápida:

Por último se concatenan los "buckets" para formar de nuevo un arreglo

de todos los elementos el cual ya está ordenado:
En el método Bucket Sort se reciben como parámetros típicamente el arreglo y el
número de "buckets"(contenedores o subarreglos) a utilizar.

En el primer paso se tienen que encontrar los valores máximo y mínimo del arreglo
para poder determinar cuales serán los intervalos que trabajará cada "bucket", una
vez determinados se tienen que extraer los elementos del arreglo y pasar cada
uno a su "bucket" correspondiente.

El segundo paso no corresponde totalmente a este método de ordenacion, ya que

es en este que se utiliza típicamente otro método para ordenar, como lo serían el
de Insert Sort o Bubble Sort, aplicando estos algoritmos a cada uno de los
"buckets" generados en el paso anterior.

El tercer paso, una vez ya ordenados los "buckets" se procede a concatenarlos en

un arreglo final.

---

Bucket Sort se origina a partir del método Counting Sort. Counting Sort lo que
hace es solo separar cada número del arreglo original, y después se coloca de
vuelta en su lugar final. Bucket Sort básicamente está haciendo lo mismo, excepto
que lo hace con múltiples números a la vez.

package bucket.sort;
import java.util.*;
public class BucketSort {
private static int i;
public static Vector<Integer> sort(Vector<Integer> lista, int inferior,int superior)
{
int rango= (superior-inferior);
int bucket_size = rango/10;

Vector<Vector> listas = new Vector<Vector>();

/* creamos las listas de ordenamiento */
for(int i=0;i<10;i++)
listas.addElement(new Vector<Integer>());

/*
 agregamos cada uno de los elemento en la lista que corresponde
*/
for(int i=0;i<lista.size();i++)
{
/* calculamos en la lista que le corresponde */
int casilla = (lista.elementAt(i)-inferior)/bucket_size;
/* Agregamos el elemento a la lista calculada */
Vector<Integer> vCasilla = listas.elementAt(casilla);
vCasilla.addElement(lista.elementAt(i));
}

/* Ordenamos las listas con un metodo de ordenamiento

en este caso utilizaremos el mismo metodo de ordenamiento
el BucketSort recursivo. */
Vector<Integer> out= new Vector<Integer>();
for(int i=0;i<listas.size();i++)
{
int inf= inferior+(i*bucket_size);
int sup= inferior+(i*bucket_size)+bucket_size;
/* en tmp vamos a guardar cada una de las listas pero ya ordenadas */
Vector<Integer> tmp = null;
/* si el rango es igual a 1 quiere decir que ya no hay por que ordenar si
la lista tiene un elemento quiere decir que la lista esta ordenada */
if( sup-inf == 1 || listas.elementAt(i).size() == 1)
{
tmp =listas.elementAt(i);
}
else
{
/*si no se cumple ninguna de las condiciones anteriores entonces la
lista no esta ordenada pero procedemos a ordenarla */
tmp = BucketSort.sort(listas.elementAt(i),inf,sup);
}
/*
temp contiene los elementos de una lista ordenada
Agregamos todos los elementos de las listas a una sola lista
*/
for(int j=0;j<tmp.size();j++)
out.addElement(tmp.elementAt(j));
}
 /*regresamos el contenido de todas las listas en una sola */
return out;
}

public static void main(String[] args) {

long Inicio,Fin,Tiempo;
Inicio=System.currentTimeMillis();

Random r = new Random();

Vector<Integer> lista = new Vector<Integer>();

for(int i=0;i<10000;lista.addElement(r.nextInt(10000)),i++);
System.out.println("Imprimiendo generados");
for(int i=0;i<lista.size();System.out.println(lista.elementAt(i++)));

Vector<Integer> resultado = BucketSort.sort(lista,0,10000);

System.out.println("Imprimiendo resultados");
for(i =0;i<resultado.size();i++)
System.out.println(resultado.elementAt(i));

System.out.println("");
Fin=System.currentTimeMillis();
Tiempo=Fin-Inicio;
System.out.println("Tiempo Que Tarda En Ejecutar 10,000 Numeros");
System.out.println(+Tiempo+" Mili Segundos");

}
}
 Cuadro comparativo ( Counting Sort, Bucket sort, radix sort, string
sort)
Counting Sort
1. for j=1 to \sigma do C[j] <- 0
2. for i=1 to n do C[A[i]]++
3. p<-1
4. for j=1 to \sigma do
- for i=1 to C[j] do
- A[p++] <- j
Bucket Sort
1. for j=1 to \sigma do C[j] <- 0
2. for i=1 to n do C[A[i]]++
3. P[1] <- 1
4. for j<- 2 to \sigma do
- P[j] <- P[j-1] + C[j-1]
5. for i<-1 to n
- B[P[A[i]]++] <- A[i]
Este algoritmo es bueno para ordenar multi
conjuntos (donde cada elementos puede ser
presente muchas veces), pero pobre para
diccionarios, para cual es mejor usar la extensión
lógica, Bucket Sort.
Este algoritmo es bueno para ordenar multi
conjuntos (donde cada elemento puede ser
presente muchas veces), pero pobre para
diccionarios no posee la sentencia if.
funciona mejor con una lista larga, de un solo
elemento simple: no hay structs, y de números
repetitivos. Es mejor que los números no se
separen mucho entre sí.
Eficiencia:
No existe un mejor y peor caso, todos los casos se
tratan iguales
Facilidad de implementación:
Utiliza el diapasón de los números del array a
ordenar (lista) para calcular los elementos que
coinciden.
Restricciones:
Sólo puede ser aplicado en elementos en un
intervalo de a lo más k elementos, típicamente en
números naturales en el rango de 1 a k. Su cota
de tiempo es de O (n + k), por lo que para ser mejor
que el ordenamiento a base de comparaciones, se
debe cumplir que k < O.
Este algoritmo es particularmente practica para
ordenar llaves asociadas con objetos, donde dos
llaves pueden ser asociadas con algunas valores
distintas.
Es principalmente útil cuando la entrada se
distribuye uniformemente en un rango.
 Es rápido porque asume algo sobre la entrada
(como counting sort, asume números en un rango
pequeño).
El tiempo para clasificar los elementos es
constante. El tiempo de clasificar los elementos en
el peor de los casos es O(n log n).

Eficiencia:
Es eficiente y veloz método de ordenamiento
interno.

Facilida de implementación:
Se trata de una generalización del algoritmo
Pigeonhole sort. Cuando los elementos a ordenar
están uniformemente distribuidos la complejidad
computacional de este algoritmo es de O(n).

Restricciones:
Requiere más memoria auxiliar para los cubos a
costa del tiempo de ejecución que más géneros de
comparación. Funciona en O (n + k)
O (n + k) tiempo en el caso promedio donde n es la
cantidad de elementos que se ordenarán y k es la
cantidad de cubos.

Radix Sort El ordenamiento es razonablemente eficiente si el

Radix-Sort(A, d)
for j = 1 to d do número de dígitos en las llaves no es demasiado
int count[10] = {0}; grande.
for i = 0 to n do
count[key of(A[i]) in pass j]++ Radix Sort es uno de los algoritmos de clasificación
for k = 1 to 10 do lineal más eficientes y rápidos. Es fácil de entender
count[k] = count[k] + count[k-1]
for i = n-1 downto 0 do y fácil de implementar. Radix Sort es una buena
result[ count[key of(A[i])] ] = A[j]
count[key of(A[i])]--
opción para muchos programas que necesitan una
for i=0 to n do clasificación rápida.
A[i] = result[i]
end for(j)
Radix Sort puede manejar claves más grandes de
end func manera más eficiente en comparación con
Counting Sort.

Eficiencia:
Es rápido a diferencia de otros algoritmos de
ordenamiento.
 Facilidad de implementación:
Hacer una clasificación dígito por dígito
comenzando desde el dígito menos significativo
hasta el dígito más significativo.

Restricciones:
No podemos usar la ordenación por conteo porque
la clasificación por conteo tomará O (n 2 ).

Necesita espacio adicional, por lo menos, tanto

como la entrada.

Discutir cuando el algoritmo es más adecuado que los algoritmos

basados en comparaciones.

 Comparando, vemos que Radix Sort es uno de los algoritmos de

clasificación lineal más eficientes y rápidos. Es fácil de entender y
fácil de implementar. Radix Sort es una buena opción para muchos
programas que necesitan una clasificación rápida. Además, vemos
que Radix Sort puede manejar teclas más grandes de manera más
eficiente en comparación con Counting Sort y que el Bucket Sort (que
consume mucha memoria). La clasificación Radix es más eficiente
que las mejores clasificaciones basadas en la comparación.

 Aunque:
Para seleccionar exactamente uno, debemos identificar básicamente
el escenario adecuado para saber de esta manera con que algoritmo
se debe operar con el fin de optimizar el mejor caso y encontrar una
solución rápida,
Porque, algunos algoritmos lentos se comportan en un orden
cuadrático, es decir, O(n²), mientras que los algoritmos rápidos se
comportan, en un caso promedio en un orden logarítmico, es decir, O
(n log n). Con esta base podremos tener la idea de que algoritmo será
el apropiado.

 Además:
Al utilizar informaci´on adicional de los elementos es posible diseñar
algoritmos de ordenamiento que corren en tiempo o(n log n)
• Counting-Sort asume que los elementos a ordenar son n enteros
en el rango {0, . . . , k} y corre en tiempo Θ(n + k)
• Radix-Sort asume que los elementos a ordenar son n enteros de a
lo sumo d d´ıgitos y corre en tiempo Θ(dn)
• Bucket-Sort asume que los elementos a ordenar son n n´umeros
reales en [0, 1) generados de forma uniforme e independiente, y
corre en tiempo esperado Θ(n)
 Bibliografía

Counting Sort, Bucket sort, radix sort, string sort. (s.f.). Algoritmos de Ordenamiento (
Counting Sort, Bucket sort, radix sort, string sort). Recuperado el 17 de junio de
2019, de https://www.u-cursos.cl/ingenieria/2010/2/CC4102/1/blog/o/2035
Artículos con clase. (s.f.). Ordenamiento por Cuenta (Counting Sort). Recuperado el 21 de
junio de 2019, de
http://articulos.conclase.net/?tema=ordenacion&art=cuenta&pag=000
CODINGEEK. (s.f.). Clasificación de radix - explicación, pseudocódigo e implementación.
Recuperado el 21 de junio de 2019, de
https://www.codingeek.com/algorithms/radix-sort-explanation-pseudocode-and-
implementation/
GeerForGeeks. (s.f.). Radix Sort. Recuperado el 19 de junio de 2019, de
https://www.geeksforgeeks.org/radix-sort/
javacodex.com. (s.f.). Counting Sort. Recuperado el 22 de junio de 2019, de
https://www.javacodex.com/Sorting/Counting-Sort
Neocities Ordenamientos. (s.f.). Neocities Ordenamientos Sort. Recuperado el 17 de junio
de 2019, de https://bucketsort.neocities.org/ejemplo.html
Wikipedia. (s.f.). Ordenamiento por casilleros. Recuperado el 17 de junio de 2019, de
https://es.wikipedia.org/wiki/Ordenamiento_por_casilleros
Wikipedia. (s.f.). Ordenamiento por cuentas. Recuperado el 21 de junio de 2019, de
https://es.wikipedia.org/wiki/Ordenamiento_por_cuentas#Limitaciones