Makefile

@@ -1,7 +1,7 @@
 CC=gcc
 CFLAGS=-Wall -Isrc/include -DDEBUG -g
 LDFLAGS=-lm
-SRC=src/sort.c src/random.c src/bubble_sort.c src/timer.c src/count_sort.c src/quick_sort.c src/merge_sort.c src/bitonic_sort.c src/selection_sort.c
+SRC=src/sort.c src/random.c src/bubble_sort.c src/timer.c src/counting_sort.c src/quick_sort.c src/merge_sort.c src/bitonic_sort.c src/selection_sort.c
 OBJ=$(SRC:.c=.o)
 
 all: sort informe

README.md

@@ -18,3 +18,5 @@ Comprobar que los algoritmos y programa corren como esperado
 	make informe
 Compilar el informe si pdflatex está disponible en el sistema
 
+## Correr el programa
+	./sort

doc/Informe.tex

@@ -16,11 +16,14 @@
 \lstset{
 	basicstyle=\small\ttfamily,
 	columns=flexible,
-	breaklines=true
+	breaklines=true,
+	inputencoding=utf8,
+	extendedchars=true,
+	literate={á}{{\'a}}1 {é}{{\'e}}1 {í}{{\'i}}1 {ó}{{\'o}}1 {ú}{{\'u}}1 {ñ}{{\~n}}1 {Á}{{\'A}}1 {É}{{\'E}}1 {Í}{{\'I}}1 {Ó}{{\'O}}1 {Ú}{{\'U}}1 {Ñ}{{\~N}}1
 }
 
 \usepackage{hyperref}
-\hypersetup{pdftex,colorlinks=true,allcolors=black,bookmarks}
+\hypersetup{colorlinks=true,allcolors=black,bookmarks,pdftitle={Tarea 1: Ordenamiento}}
 \usepackage{hypcap}
 
 \pretitle{%
@@ -62,25 +65,138 @@ Xavier Canales
 
 \newpage
 \pagenumbering{arabic}
-
-\section{Psuedo código}
-
+\section{Pseudo código}
 \subsection{Merge Sort}
+\lstinputlisting{pseudo/mergesort.txt}
 
+\newpage
 \subsection{Quick Sort}
+\lstinputlisting{pseudo/quicksort.txt}
 
+\newpage
 \subsection{Bubble Sort}
-\lstinputlisting{psuedo/bubblesort.txt}
+\lstinputlisting{pseudo/bubblesort.txt}
 
+\newpage
 \subsection{Bitonic Sort}
+\lstinputlisting{pseudo/bitonicsort.txt}
 
-\subsection{Ordenamiento por conteo}
+\newpage
+\subsection{Counting Sort}
+\lstinputlisting{pseudo/countingsort.txt}
 
-\subsection{Ordenamiento por selección}
+\newpage
+\subsection{Selection Sort}
+\lstinputlisting{pseudo/selectionsort.txt}
 
-\section{Análisis temporal}
+\newpage
+\section{Resultados}
 
+\subsection{Análisis temporal}
+\subsubsection{Merge Sort}
+\underline{Caso Promedio:} $ \Theta(n log n)) $ \\
+El caso promedio de merge sort es similar a peor caso. \\
+
+\underline{Peor Caso:} $ O(n log n) $ \\
+En el peor de los casos, el merge sort hace aproximadamente un 39\% menos de comparaciones que el quick sort en su caso promedio. En términos de movimientos, la complejidad del peor de los casos de merge sort es $ O(n log n) $ la misma complejidad que el mejor de Quick sort, y el mejor de la clasificación de merge sort toma aproximadamente la mitad de las iteraciones que en el peor de los casos. \\
+
+\underline{Mejor Caso:} $ \Omega(n log n)$ \\
+En el caso mejor de merge sort, el merge sort funciona mejor cuando los datos son secuencial. \\
+
+\subsubsection{Quick Sort}
+\underline{Caso Promedio:} $ \Theta(n(log n)) $ \\
+El tiempo de ejecución que tendrá el algoritmo dependerá de como se realice la partición de el arreglo entrada, es decir, depende de la selección del pivote. \\
+
+\underline{Peor Caso:} $ O(n^2) $ \\
+El peor de los casos para el quick sort resultará cuando la elección del pivote sea el valor más pequeño del arreglo o el más grande de este mismo. \\
+
+\underline{Mejor Caso:} $ \Omega(n log(n)) $ \\
+Para obtener el mejor caso posible será cuando el pivote se encuentre exactamente al medio del arreglo, porque lo dividirá en dos obteniendo n/2 elementos en ambas divisiones del arreglo. \\
+
+\subsubsection{Bubble Sort}
+\underline{Caso Promedio:} $ \Theta(n^2)) $ \\
+El caso promedio compara la complejidad temporal con el peor caso, donde n es el numero de valores a ordenar, esto es producto de la forma en la cual \textit{bubble} transporta los valores dentro de su ordenamiento. \\
+
+\underline{Peor Caso:} $ O(n^2) $ \\
+En el peor caso el arreglo a ordenar va a estar ordenado en forma descendente previamente. \\
+
+\underline{Mejor Caso:} $ \Omega(n)$ \\
+El mejor caso para el bubble sort será cuando el arreglo de entrada venga previamente ordenado de menor a mayor. \\
+
+\subsubsection{Bitonic Sort}
+\underline{Caso Promedio:} $\Theta(log^2(n))$ \\
+El ordenamiento bitonico responde igual a todos los casos porque siempre antes de empezar a ordenarlos realiza las mismas comparaciones para dejarlos en la secuencia bitonica. \\
+
+\underline{Peor Caso:} $ O(log^2(n)) $ \\
+Su peor caso es igual que su caso promedio. \\
+
+\underline{Mejor Caso:} $ \Omega(log^2(n)) $ \\
+Su mejor caso es igual que su caso promedio. \\
+
+\subsubsection{Counting Sort}
+\underline{Caso Promedio:} $ \Theta(\frac{n^2}{2}) $ \\
+La complejidad total es igual para todos los casos, porque el algoritmo usa sólo ciclos simples, sin recursividad o sub-funciones, va directamente al análisis. \\
+
+\underline{Peor Caso:} $ O(\frac{n^2}{2}) $ \\
+Su peor caso es igual a su caso promedio. \\
+
+\underline{Mejor Caso:}  $ \Omega(\frac{n^2}{2}) $ \\
+Su mejor caso es igual a su caso promedio. \\
+
+\subsubsection{Selection Sort}
+\underline{Caso Promedio:} $ \Theta(n^2) $ \\
+El ordenamiento por selección no es un algoritmo de ordenamiento adaptable, realiza el mismo numero de comparaciones de elementos en el mejor caso, el caso promedio y el peor de los casos, esto se debe a que no utiliza el orden existente de las entradas del arreglo para ordenar. \\
+
+\underline{Peor Caso:} $ O(n^2) $ \\
+Su peor caso es igual a su caso promedio. \\
+
+\underline{Mejor Caso:} $ \Omega(n^2) $ \\
+Su mejor caso es igual a su caso promedio. \\
+
+\newpage
+\subsection{Datos}
+La siguiente tabla contiene los resultados de las pruebas de los 6 algoritmos medidos en segundos. Para las pruebas usábamos un computador que tiene 4 nucleos de 3.2GHz y 16GB de memoria RAM.
+\begin{center}
+	\begin{tabular}{|c|c|c|c|c|c|c|}
+		\hline
+		\multicolumn{7}{|c|}{Algoritmos de ordenamiento} \\
+		\hline
+		\rule[-1ex]{0pt}{3.5ex} & Quick  & Merge  & Bitonic  & Selection  & Counting  & Bubble \\
+		\hline
+		\rule[-1ex]{0pt}{3.5ex} 10.000 & 0.100[s] & 0.280[s] & 0.090[s] & 0.143[s] & 0.258[s] & 0.326[s] \\
+		\hline
+		\rule[-1ex]{0pt}{3.5ex} 100.000 & 0.170[s] & 0.300[s] & 0.124[s] & 11.645[s] & 30.269[s] & 32.347[s] \\
+		\hline
+		\rule[-1ex]{0pt}{3.5ex} 1.000.000 & 0.173[s] & 0.304[s] & 1.405[s] & 3,144.000[s] & 6,717.674[s] & 7,248.000[s] \\
+		\hline
+		\rule[-1ex]{0pt}{3.5ex} 5.000.000 & 2.000[s] & 1.577[s] & 7.421[s] & 60,951.000[s] & 139,273.286[s] & 153,273.539[s] \\
+		\hline
+		\rule[-1ex]{0pt}{3.5ex} 10.000.000 & 2.400[s] & 3.236[s] & 18.365[s] & 243,804.000[s] & 557,093.1440[s] & 613,094.156[s] \\
+		\hline
+	\end{tabular}
+\end{center}
+
+\newpage
+\subsection{Gráfico}
+
+\begin{center}
+	\includegraphics[width=0.96\textwidth,height=0.96\textheight,keepaspectratio]{graph.png}
+\end{center}
+
+\newpage
 \section{Conclusiones}
+Basados en los resultados obtenido podemos poner los algoritmos en orden de mas rápido a menos rápido en la siguiente forma:
+\begin{itemize}
+	\setlength\itemsep{0.1em}
+	\item Quick Sort
+	\item Merge Sort
+	\item Bitonic Sort
+	\item Selection Sort
+	\item Counting Sort
+	\item Bubble Sort
+\end{itemize}
+Al final resulta que el mas rápido algoritmo de ordenamiento que probamos fue Quick Sort mientras que el mas lento fue el Bubble Sort.
+Los resultados de tiempo de ejecución estaban de lo que esperábamos dado el complejidad de los algoritmos.
 
 \end{document}
 

doc/pseudo/bitonicsort.txt

@@ -0,0 +1,81 @@
+entrada: array: arreglo de n datos; n: tamaño del arreglo
+salida: arreglo ordenado
+
+funcion ordenamientobitonico(array, n)
+  orden(array, n, 1)
+  return array
+fin funcion
+
+funcion potencia_de_dos(n)
+  si n = 0 entonces
+    retornar 0
+  fin si
+  mientras n distinto 1 hacer
+    si n es modulo de 2 entonces
+      retornar 0
+    fin si
+  fin mientras
+  retornar 1
+fin funcion
+
+funcion mejor_potencia_de_2_menos_a_n(n)
+  k = 1
+  mientras k > 0 y k < n hacer
+	busca el numero potencia de dos mas proximo hacia abajo en n
+  fin mientras
+  retorna k
+fin funcion
+
+funcion comparar(i, j, dir, array)
+  temp = array[i]
+  array[i] = array[j]
+  array[j] = temp
+fin funcion
+
+funcion unionbitonica(low, n, dir, array)
+  si n > 1 entonces
+    k = n / 2
+    para i = low hasta i < low + k con paso i = i + 1
+		comparar(i + k, di, array)
+    fin para
+    unionbitonica(low, k, dir, array)
+    unionbitonica(low + k, k, dir, array)
+  fin si
+fin funcion
+
+funcion unionbitonico2(low, n, dir, array)
+  si n > 1 entonces
+    k = mejor_potencia_de_2_menos_a_n
+    para i = low hasta i < low + n - k con paso i = i + 1 hacer
+		comparar(i, i + k, dir, array)
+    fin para
+    ordenamientobitonico2(low, k, dir, array)
+    ordenamientobitonico2(low + k, n - k, dir, array)
+fin funcion
+
+funcion recorrerbitonico(low, n, dir, array)
+  si n > 1 entonces
+    k = n / 2
+    recorrerbitonico(low, k, 1, array)
+    recorrerbitonico(low + k, k, 0, array)
+    unionbitonica(low, n, dir, array)
+  fin si
+fin funcion
+
+funcion recorrerbitonico2(low, n, dir, array)
+  si n > 1 entonces
+    k = n / 2
+    recorrerbitonico2(low, k, !di, array)
+    recorrerbitonico2(low + k, n - k, dir, array)
+    unionbitonico2(low, n, dir, array)
+  fin si
+fin funcion
+
+funcion orden(array, n, dir)
+  si potencia_de_dos(n) entonces
+    recorrerbitonico(0, n, dir, array)
+  fin si
+  sino
+    recorrerbitonico2(0, n, dir, array)
+  fin sino
+fin funcion

doc/pseudo/bubblesort.txt

@@ -0,0 +1,19 @@
+entrada: array: arreglo de elementos enteros; n: tamaño del arreglo
+salida: arreglo array ordenado ascendentemente
+
+funcion bubblesort(array, n)
+  flag = 1
+  mientras que flag es verdad
+    flag = false
+    para i = 1 mientras que i < j con pasa i = i + 1 hacer
+      si array[i] < array[i - 1] entonces
+        temp = array[i]
+        array[i] = array[i - 1]
+        array[i - 1] = temp
+        flag = verdad
+      fin si
+    fin para
+    j = j - 1;
+  fin mientras
+  retorna array
+fin funcion

doc/pseudo/countingsort.txt

@@ -0,0 +1,22 @@
+entrada: array: arreglo de elementos enteros; n: tamaño del arreglo
+salida: arreglo array ordenado ascendentemente
+
+funcion countingsort(array, n)
+  para i = 0 mientras que i < n con paso i = i + 1 hacer
+    count[i] = 0
+  fin para
+  para i = 0 mientras que i < n - 1 con paso i = i + 1 hacer
+    para j = i + 1 mientras que j < n con paso j = j + 1 hacer
+      si array[i] < array[j] entonces
+        count[j] = count[j] + 1
+      sino
+        count[i] = count[i] + 1
+      fin si
+    fin para
+  fin para
+
+  para i = 0 mientras que i < n con paso i = i + 1 hacer
+    newarray[count[i]] = array[i]
+  }
+  retorna newarray
+fin funcion

doc/pseudo/mergesort.txt

@@ -0,0 +1,43 @@
+entrada: array: arreglo de n datos; n: tamaño del arreglo
+salida: arreglo ordenado
+
+funcion mergesort(array, n)
+  correr_mergesort(array, 0, n - 1);
+  retorna array
+fin funcion
+
+funcion correr_mergesort(array, izquerda, derecha)
+  si izquerda != derecha entonces
+    medio = (izquerda + derecha) / 2
+    correr_mergesort(array, izquerda, medio)
+    correr_mergesort(array, medio + 1, derecha)
+    unir(array, izquerda, medio + 1, derecha)
+  fin si
+fin funcion
+
+funcion unir(array, previo_izquerda, previo_medio, derecha)
+  i = 0
+  izquerda = previo_izquerda
+  medio = previo_medio - 1
+  far_derecha = derecha - izquerda + 1
+
+  mientras que previo_izquerda <= medio y previo_medio <= derecha hacer
+    si array[previo_izquerda] < array[previo_medio] entonces
+      temp[i++] = array[previo_izquerda++]
+    sino
+      temp[i++] = array[previo_medio++]
+    fin si
+  fin mientras
+
+  mientras que previo_izquerda <= medio hacer
+    temp[i++] = array[previo_izquerda++]
+  fin mientras
+
+  mientras que previo_medio <= derecha hacer
+    temp[i++] = array[previo_medio++]
+  fin mientras
+
+  para i = 0 mientras que i < far_derecha con paso i = i + 1 hacer
+    array[izquerda + i] = temp[i]
+  fin para
+fin funcion

doc/pseudo/quicksort.txt

@@ -0,0 +1,33 @@
+entrada: array: arreglo de n datos; n: tamaño del array
+salida: arreglo ordenado
+
+funcion quick_sort(array, n)
+  si n < 2 entonces
+    retorna
+  fin si
+
+  pivote = array[n / 2]
+
+  para i = 0 y j = n - 1 con paso i = i + 1 y j = j - 1 hacer
+    mientras que array[i] < pivote hacer
+      i = i + 1
+    fin mientras
+
+    mientras que array[j] > pivote hacer
+      j = j - 1
+    fin mientras
+
+    si i >= j entonces
+      break
+    fin si
+
+    temp = array[i]
+    array[i] = array[j]
+    array[j] = temp
+  fin para
+
+  quick_sort(array, i)
+  quick_sort(array + i, n - i)
+
+  retorna array
+fin funcion

doc/pseudo/selectionsort.txt

@@ -0,0 +1,17 @@
+entrada: array: arreglo de n datos; n: tamaño del arreglo
+salida: arreglo ordenado
+
+funcion selection_sort(array, n)
+  para i = 0 hasta i < n - 1 con paso i = i + 1 hacer
+    min_idx = i
+    para j = i + 1 hasta j < n con paso j = j + 1 hacer
+      si array[j] < array[min_idx] entonces
+        min_idx = j
+      fin si
+    fin para
+    temp = array[min_idx]
+    array[min_idx] = array[i]
+    array[i] = temp
+  fin para
+  retorna array
+fin funcion

doc/psuedo/bubblesort.txt

@@ -1,9 +0,0 @@
-cuentaDeElementos := n
-repetir
-  haCambiado := falso
-  disminuir cuentaDeElementos
-  repetir con indice desde 1 a cuentaDeElementos
-    if (elemento en indice) > (elemento en (indice + 1))
-      intercambiar (elemento en indice) con (elemento en (indice + 1))
-      haCambiado := falso
-hasta haCambiado = verdad

src/bitonic_sort.c

@@ -114,7 +114,7 @@ void bitonicmerge_no2(int low, int n, int dir, int *array) {
 void recbitonic(int low, int n, int dir, int *array) {
 	int k;
 
-	if (n > 1){
+	if (n > 1) {
 		k = n / 2;
 		recbitonic(low, k, 1, array);
 		recbitonic(low + k, k, 0, array);

src/counting_sort.c

@@ -22,7 +22,7 @@
  * @param array El array a ordenar
  * @param n El tamaño del array
  */
-void count_sort(int *array, int n) {
+void counting_sort(int *array, int n) {
 	int i;
 	int j;
 	int *temp = malloc(sizeof(int) * n);

src/include/counting_sort.h

@@ -13,7 +13,7 @@
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _SORT_COUNT
-	#define _SORT_COUNT
-	void count_sort(int *array, int n);
+#ifndef _SORT_COUNTING
+	#define _SORT_COUNTING
+	void counting_sort(int *array, int n);
 #endif

src/sort.c

@@ -22,7 +22,7 @@
 #include "random.h"
 #include "timer.h"
 #include "bubble_sort.h"
-#include "count_sort.h"
+#include "counting_sort.h"
 #include "quick_sort.h"
 #include "bitonic_sort.h"
 #include "selection_sort.h"
@@ -49,7 +49,7 @@ void print_usage() {
 	fprintf(stdout, "  -q, --quick                usar quick sort\n");
 	fprintf(stdout, "  -b, --bubble               usar bubble sort\n");
 	fprintf(stdout, "  -B, --bitonic              usar bitonic sort\n");
-	fprintf(stdout, "  -c, --count                usar ordenamiento por conteo\n");
+	fprintf(stdout, "  -c, --counting             usar ordenamiento por conteo\n");
 	fprintf(stdout, "  -s, --selection            usar ordenamiento por selección\n");
 	fprintf(stdout, "  -n, --n=N                  la cantidad de elementos a ordenar, la\n");
 	fprintf(stdout, "                             cantidad predeterminado es 10\n");
@@ -57,6 +57,7 @@ void print_usage() {
 	fprintf(stdout, "                             elementos a ordenar, sin esta opción los\n");
 	fprintf(stdout, "                             valores son elegido por el programa al azar\n");
 	fprintf(stdout, "  -i, --imprimir             imprimir el array antes y despues de ordenar\n");
+	fprintf(stdout, "  -h, --help                 mostrar como usar el programa\n");
 	fprintf(stdout, "  -v, --version              mostrar la versión del programa\n");
 }
 
@@ -182,7 +183,7 @@ int main (int argc, char **argv) {
 	int quick = 0;
 	int bubble = 0;
 	int bitonic = 0;
-	int count = 0;
+	int counting = 0;
 	int selection = 0;
 	int opt;
 	int long_index = 0;
@@ -192,11 +193,12 @@ int main (int argc, char **argv) {
 		{"quick",		no_argument,		0,	'q'},
 		{"bubble",		no_argument,		0,	'b'},
 		{"bitonic",		no_argument,		0,	'B'},
-		{"count",		no_argument,		0,	'c'},
+		{"counting",	no_argument,		0,	'c'},
 		{"selection",	no_argument,		0,	's'},
 		{"n",			required_argument,	0,	'n'},
 		{"elegir",		no_argument,		0,	'e'},
 		{"imprimir",	no_argument,		0,	'i'},
+		{"help",		no_argument,		0,  'h'},
 		{"version",		no_argument,		0,	'v'},
 		{0, 0, 0, 0}
 	};
@@ -206,14 +208,14 @@ int main (int argc, char **argv) {
 		return 0;
 	}
 
-	while ((opt = getopt_long(argc, argv, "amqbBcsn:eiv", long_options, &long_index)) != -1) {
+	while ((opt = getopt_long(argc, argv, "amqbBcsn:eihv", long_options, &long_index)) != -1) {
 		switch (opt) {
 			case 'a':
 				merge = 1;
 				quick = 1;
 				bubble = 1;
 				bitonic = 1;
-				count = 1;
+				counting = 1;
 				selection = 1;
 				break;
 			case 'm':
@@ -229,7 +231,7 @@ int main (int argc, char **argv) {
 				bitonic = 1;
 				break;
 			case 'c':
-				count = 1;
+				counting = 1;
 				break;
 			case 's':
 				selection = 1;
@@ -281,6 +283,9 @@ int main (int argc, char **argv) {
 			case 'i':
 				imprimir = 1;
 				break;
+			case 'h':
+				print_usage();
+				return 0;
 			case 'v':
 				printf("sort versión: %s\n", SORT_VERSION);
 				return 0;
@@ -291,7 +296,7 @@ int main (int argc, char **argv) {
 		}
 	}
 
-	if (!merge && !quick && !bubble && !bitonic && !count && !selection) {
+	if (!merge && !quick && !bubble && !bitonic && !counting && !selection) {
 		fprintf(stderr, "Error: No se seleccionó un algoritmo valido!\n");
 		print_usage();
 		return 4;
@@ -346,10 +351,10 @@ int main (int argc, char **argv) {
 		end_sort();
 	}
 
-	// O(n^2)
-	if (count) {
-		start_sort("Count sort corriendo... ", n);
-		count_sort(work_array, n);
+	// O((1/2) * n^2 - (1/2) * n)
+	if (counting) {
+		start_sort("Counting sort corriendo... ", n);
+		counting_sort(work_array, n);
 		end_sort();
 	}
 

test/Makefile

@@ -3,7 +3,7 @@ CFLAGS=-Wall -I../src/include -DDEBUG -g
 SRC=test.c
 OBJ=$(SRC:.c=.o)
 
-OBJ+=../src/random.o ../src/bubble_sort.o ../src/count_sort.o ../src/quick_sort.o ../src/merge_sort.o ../src/bitonic_sort.o ../src/selection_sort.o
+OBJ+=../src/random.o ../src/bubble_sort.o ../src/counting_sort.o ../src/quick_sort.o ../src/merge_sort.o ../src/bitonic_sort.o ../src/selection_sort.o
 
 all: test
 

test/test.c

@@ -19,7 +19,7 @@
 #include <unistd.h>
 #include "random.h"
 #include "bubble_sort.h"
-#include "count_sort.h"
+#include "counting_sort.h"
 #include "selection_sort.h"
 #include "bitonic_sort.h"
 #include "merge_sort.h"
@@ -124,12 +124,12 @@ int main(int argc, char **argv) {
 		passed++;
 	}
 
-	// Test count sort
+	// Test counting sort
 	pass = 1;
 	memcpy(test_array, test_case, sizeof(int) * n);
-	fprintf(stdout, "\tcount sort: ");
+	fprintf(stdout, "\tcounting sort: ");
 	fflush(stdout);
-	count_sort(test_array, n);
+	counting_sort(test_array, n);
 	for (i = 0; i < n; i++) {
 		if (test_array[i] != qarray[i]) {
 			fprintf(stdout, "fail\n");