ALGORITMOS DE ORDENAMIENTO COUNTING SORT

CHRISTIAN ESTEBAN ALDANA ROZO BRAYAN STIF FORERO CRUZ

GIOVANNY GUZMÁN CÉSPEDES JORGE MEJIA

Profesora: DIANA MABEL DIAZ

UNIVERSIDAD PILOTO DE COLOMBIA INGENIERIA DE SITEMAS

ANALISIS Y DISEÑO DE ALGORTIMOS BOGOTA D.C.

2010

BIBLIOGRAFIA

http://es.wikipedia.org/wiki/Algoritmo_de_ordenamiento

http://books.google.com.co/books?id=NLngYyWFl_YC&pg=PA168&lpg=PA168&dq=counting+sort+cormen&source=bl&ots=BwVsEE-nFb&sig=0BubWTzl9Rk0cwlgkTLZXZlx9vU&hl=es&ei=rtWtTLa2D4O8lQeR55zUBQ&sa=X&oi=book_result&ct=result&resnum=1&ved=0CBcQ6AEwAA#v=onepage&q&f=false

http://es.wikipedia.org/wiki/Ordenamiento_por_cuentas

http://www.ritmodominicano.com/wiki.php?title=Discusi%C3%B3n:Algoritmo_de_ordenamiento

http://ing.utalca.cl/~jperez/ae/documentos/ordenacion.pdf

HISTORIA

El algoritmo de ordenamiento Counting Sort (Ordenamiento por Cuentas en español) 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, por ejemplo, los números enteros de un determinado intervalo, sin contar números reales. El algoritmo fue creado por Harold H. Seward en 1954,

ANÁLISIS DEL ALGORITMO El primer paso consiste en averiguar cuál es el intervalo dentro del que están los datos a ordenar (valores mínimo y máximo). Después se crea un vector de números enteros con tantos elementos como valores haya en el intervalo [mínimo, máximo], y a cada elemento se le da el valor 0 (0 apariciones). Tras esto se recorren todos los elementos a ordenar y se cuenta el número de apariciones de cada elemento (usando el vector que hemos creado). Por último, basta con recorrer este vector para tener todos los elementos ordenados.

1. para i ← 0 hasta r 2. hacer C[ i ] ← 0 3. para j ← 1 hasta n 4. hacer C[A[ j ]] ← C[A[ j ]] + 1 5. C[i] contiene el número de elementos igual a i 6. para i ← 1 hasta r 7. hacer C[ i ] ← C[ i ] + C[i -1] 8. C[i] contiene el número de elementos ≤ i 9. para j ← n abajo de 1 10. hacer B[C[A[ j ]]] ← A[ j ] 11. C[A[ j ]] ← C[A[ j ]] - 1

Se trata de un algoritmo estable cuya complejidad computacional es O(n+k), siendo n el número de elementos a ordenar y k el tamaño del vector auxiliar (máximo - mínimo). Si este último intervalo es muy amplio, el algoritmo es ineficiente, ya que el vector auxiliar tiene un tamaño excesivamente grande, lo que supondría un gran coste en memoria y también en tiempo. Con lenguajes de programación que no permitan definir vectores cuyo primer índice sea un valor distinto de 0 ó 1 es necesario realizar una traducción de los valores. Por ejemplo, si el intervalo es [4,10] y el vector auxiliar se define como vaux = vector[1..7], el valor 6 deberá incrementar el contador de la posición vaux[3].Si en lugar de esta simple traducción se utilizan funciones más complejas, entonces el algoritmo se denominaría bucket sort. Counting sort es un algoritmo de ordenamiento similar al algoritmo de Bucket sort, este algoritmo tiene la ventaja de conocer el rango de los números de la matriz a ordenar (matriz A). Utiliza este rango para crear una matriz C de esta longitud. Cada índice i en C matriz se utiliza para contar el número de elementos en una cuenta con el valor, y luego cuenta almacenada en C se puede utilizar para poner los elementos de A en su posición correcta en la matriz resultante ordenados. El algoritmo fue creado por Harold H. Seward en 1954.

CORRECTITUD INICIO: Los datos de entrada para desarrollar el algoritmo son un vector A con los números a organizar y una constante k que será el limite. MANTENIMIENTO (INVARIANTE) El único valor que no cambia dentro del desarrollo del algoritmo es el valor de K, puesto que es una constante que nos dará el número de posiciones que tendrá el vector C. FINALIZACIÓN 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. En el primer ciclo se crea un vector llamado C de longitud igual a k y se hace igual a cero en todas sus posiciones, el segundo ciclo al vector C se le asigna el valor 1 en la posición correspondiente al valor del vector de los números A, es decir, si el vector que contiene los números en la posición 0 equivale a 5, entonces, el vector C en la posición 5 va valer 1. El propósito del tercer ciclo es sumar los valores de las dos posiciones continuas, es decir, se suma la posición 0 con la posición 1 y se le asigna el valor a la posición 1. El último ciclo el nuevo vector B en la posición del vector que obtuvimos en el segundo ciclo solo que disminuido una unidad se le asigna el valor del vector A en dicha posición.

COMPLEJIDAD

La primera observación importante del procedimiento Counting-Sort tiene que ver con su complejidad. El primer y último ciclo toman tiempo lineal con respecto a n, y el ciclo intermedio toma tiempo lineal con respecto a k, por lo que el tiempo total para countingsort es O(n +k). Esto nos dice que en una situación práctica en la que k sea O(n), countingsort tardará tiempo lineal con respecto a n, O(n) en el peor caso mejorando la cota (n log n). La segunda observación tiene que ver con esto ´último, countingsort en ningún momento realiza comparaciones entre los elementos que se quieren ordenar por lo que la cota (n log n) no es válida para ´el. Como última observación

alguien podría preguntarse por qué el último ciclo es desde n−1 a 0 y no desde 0 a n−1. De hecho, si el ciclo se realizara aumentando el contador, Counting-Sort seguiría ordenando los valores. El ciclo se hace decrementando el contador para darle a Counting-Sort la importante propiedad de ser estable. Un algoritmo de ordenación es estable cuando para cada par de elementos iguales, estos aparecen finalmente en el mismo orden en el que aparecían en el arreglo inicial. En el próximo algoritmo que estudiemos veremos la importancia de esta propiedad.

para i ← 0 hasta k

O(k) hacer C[ i ] ← 0 para j ← 1 hasta n O(n) hacer C[A[ j ]] ← C[A[ j ]] + 1 C[i] contiene el número de elementos igual a i para i ← 1 hasta k O(k) hacer C[ i ] ← C[ i ] + C[i -1] C[i] contiene el número de elementos ≤ i para j ← n abajo de 1 hacer B[C[A[ j ]]] ← A[ j ] O(n) C[A[ j ]] ← C[A[ j ]] - 1

Tiempo total: ∑ O(n+k)

int[] C = new int[k+1];

(ta)(tv)

int[] B = new int[A.length];

(ta.tv)+k

for(int i=0;i<=k;i++){

(n-1)[ta+tc(n-1)+ti(n-i)]

C[i]=0; }

(ta)(n-1)

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

(n-1)[ta+2tc(n-k+1)(n-1)]

C[A[j]]+=1; }

(2ta)(n-1)

for(int i=1;i<=k;i++){

(n-1)[ta+2tc(n+k(n-1))]

C[i]+=C[i-1]; }

(2ta)(n-i-1)

for(int j=A.length-1;j>=0;j--){

(n-1)(3ta+3tc)(n-i-1)

B[C[A[j]]-1]=A[j];

(3ta)(n-1)+n

C[A[j]]-=1; }

(2ta)(n-i-1)

N Tiempo

1 1

10 2

50 3

100 7

500 24

1000 57

5000 117

10000 197

50000 420

100000 955

500000 4522

1000000 12993

2000000 28909

Después de medir el tiempo de ejecución del CountingSort obtuvimos la gráfica anterior, por lo cual podemos decir que es de orden O(n+k).

0

10000

20000

30000

0 500000 1000000 1500000 2000000

n

t

CountingSort

CountingSort

Lineal (CountingSort)

Tiempos de ejecución del algoritmo

n=10

n=100

n=1000

n=10000

n=100000

n=1000000