El tema que 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 (Ordenamiento Por Cuentas)
Descripción:
Algoritmo de ordenamiento en el cual se cuenta la cantidad de elementos para luego
ordenarlos. Este método solo es funcional para números enteros solamente además es uno
de los únicos que no requiere de comparaciones para su ejecución.
1) Este se puede resumir de la siguiente manera:

1- Lo primero que se debe realizar es identificar es el intervalo en el cual se

encuentran los números a ordenar el valor Maximo y el Minimo.
2- Lo siguientes es crea un nuevo vector con la misma cantidad de elementos que
valores que hay en el intervalo, a cada uno de los elementos se le da el valor de 0.
3- Ahora se recorre todos lo elemento que se quieren ordenar y se cuenta el número de
veces que aparece cada elemento. Se usa el vector que se creó anteriormente.
4- Por ultimo se debe recorrer este último vector para tener los elementos ordenados.

Pseudocódigo
Inicio

Crea lista valores

valorLista
hallar
valorMaximo<-maximo(valorLista)
valorMinimo<-minimo(valorLista)

Nuevo vector auxiliar

rango<-(valorMaximo-valorMinimo+1)
auxv=vector nuevo[rango]enteros

Todo el vector = 0
 inicia para
j=valorMinimo hasta valormaximo relizar auxv[j]<-0
fin ciclo para

Contar

inicia para
j=1 hasta longitud(valorLista)realizar
actualvalor<-valorLista[j]
auxv[actualvalor] <-auxv[valorActual]+1
fin ciclo para
Ordenar lista
elementAct<-1
inicia para
j=valorMinimo hasta valormaximo relizar
inicia para
j=1 hasta auxv[j] realizar
valorLista[elementAct]<-j
elementAct<-elementAct+1
fin ciclo para
fin ciclo para

fin programa

2) Código Java

import java.util.Arrays;
public class Main {
public static void main(String args[]) {
int [] arreglo = {20, -2, 11, 7, 1};
System.out.println("Este es el vector desordenado"+Arrays.toString(arreglo));
cuenta(arreglo);
System.out.println("Este es el vector ordenado"+Arrays.toString(arreglo));

public static void cuenta(int[] arreglo) {

int arrayLength = arreglo.length;
if(arrayLength == 0)
return;
int max, min;
min=max=arreglo[0];
for (int y=1;y<arrayLength;y++){
if(arreglo[y]>max){
max=arreglo[y];
}
if(arreglo[y]<min){
min=arreglo[y];
}
}
int rango =max-min+1;
int [] auxv=new int [rango];

for(int j=0;j < arrayLength; j++) {

auxv[arreglo[j]-min]++;
}

for(int j=1;j<rango; j++) {

auxv[j] += auxv[j-1];
}
int k=0;
for(int j=0; j<rango;j++) {
while(k<auxv[j])
arreglo[k++]=j+min;
}

}
}
 Radix Sort (Ordenamiento por casillero)
Descripción:
Este algoritmo de ordenamiento se basa en distribuir todos los elementos en casilleros, en
los casilleros solo pueden alojarse lo elementos que cumplan con las condiciones
excluyentes que son intervalos numéricos para cada casillero, después de esto los casilleros
son ordenados de forma individual por un algoritmo (Pigeonhole sort) de ordenamiento.
1) Este se puede resumir de la siguiente manera:

1- Se crean los casilleros vacíos.

2- Se guarda cada elemento que se debe ordenar en solo un casillero.
3- Se ordena de forma individual cada casillero.
4- Por último, los de los casilleros son concatenados por orden cada uno.

Pseudocódigo
Inicio

función bucket(listaEntrada, nCasilleros)

casilleros<-colección de nCasilleros

inicia para
j= 1 hasta logintud(listaEntrada)realizar
c<-buscar del casillero correspondiente
ingresar listaEntrada[i]en carollero[c]
fin ciclo para
devolver combinación de casillero[1],…..casillero[n];

fin programa

2) Código Java
import java.util.*;
public class BucketSort{

public static void main(String args[]) {

int [] arreglo = {20, 2, 11, 7, 1};
System.out.println("Este es el vector
desordenado"+Arrays.toString(arreglo));
bucket(arreglo);
System.out.println("Este es el vector ordenado"+Arrays.toString(arreglo));
}

public static void bucket(int[] arreglo) {

int arrayLength = arreglo.length;

if(arrayLength == 0)
return;
int max;
max=arreglo[0];
for (int y=1;y<arrayLength;y++){
if(arreglo[y]>max){
max=arreglo[y];
}
}

int [] array=new int [max + 1];

for(int j=0; j<array.length; j++) {

array[j]=0;
 }

for(int j=0; j<arreglo.length; j++) {

array[arreglo[j]]++;
}

int a=0;
for(int j=0; j<array.length;j++) {
for(int y=0; y<array[j]; y++) {
arreglo[a++]=j;
}
}

}
}

Radix Sort (Ordenamiento de raíz)

Descripción:
Este algoritmo es uno de los más completos ya que soporta otro tipo de datos como lo son
(nombre y fechas) y no se limita a los enteros.
1) Este se puede resumir de la siguiente manera:

1- Se ubican por dígitos en el caso de los números por unidades decena y centenas…
2- La ubicación se debe realizar por grupos del 0 al 9 de derecha a izquierda y
recoger.
3- Se debe realizar nuevamente el ejercicio, pero esta vez involucrando a segundo
digito decenas, recoger.
4- Al repetir este procedimiento se llega al orden.

Webgrafía
www.wikispaces.com
1 - https://estructuras-de-datos.wikispaces.com/BUCKET+SORT
2- https://estructuras-de-datos.wikispaces.com/Counting+sort+grupo+3
www.javacodex.com
1- https://www.javacodex.com/Sorting/Bucket-Sort