diff --git a/Makefile b/Makefile index df27027..eb10ead 100644 --- a/Makefile +++ b/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 diff --git a/README.md b/README.md index b5f83e9..12cf0dc 100644 --- a/README.md +++ b/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 \ No newline at end of file diff --git a/doc/Informe.tex b/doc/Informe.tex index 910bc03..b6c0ad3 100644 --- a/doc/Informe.tex +++ b/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} diff --git a/doc/graph.png b/doc/graph.png new file mode 100644 index 0000000..63e2cd9 Binary files /dev/null and b/doc/graph.png differ diff --git a/doc/pseudo/bitonicsort.txt b/doc/pseudo/bitonicsort.txt new file mode 100644 index 0000000..ceb64ae --- /dev/null +++ b/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 diff --git a/doc/pseudo/bubblesort.txt b/doc/pseudo/bubblesort.txt new file mode 100644 index 0000000..10169d2 --- /dev/null +++ b/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 diff --git a/doc/pseudo/countingsort.txt b/doc/pseudo/countingsort.txt new file mode 100644 index 0000000..ef3e8bb --- /dev/null +++ b/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 diff --git a/doc/pseudo/mergesort.txt b/doc/pseudo/mergesort.txt new file mode 100644 index 0000000..bd9b2b9 --- /dev/null +++ b/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 diff --git a/doc/pseudo/quicksort.txt b/doc/pseudo/quicksort.txt new file mode 100644 index 0000000..d999775 --- /dev/null +++ b/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 diff --git a/doc/pseudo/selectionsort.txt b/doc/pseudo/selectionsort.txt new file mode 100644 index 0000000..06e930e --- /dev/null +++ b/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 diff --git a/doc/psuedo/bubblesort.txt b/doc/psuedo/bubblesort.txt deleted file mode 100644 index c3cc70c..0000000 --- a/doc/psuedo/bubblesort.txt +++ /dev/null @@ -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 diff --git a/src/bitonic_sort.c b/src/bitonic_sort.c index 61751cb..e50cb93 100644 --- a/src/bitonic_sort.c +++ b/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); diff --git a/src/count_sort.c b/src/counting_sort.c similarity index 98% rename from src/count_sort.c rename to src/counting_sort.c index 6ba0c3f..3aca154 100644 --- a/src/count_sort.c +++ b/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); diff --git a/src/include/count_sort.h b/src/include/counting_sort.h similarity index 94% rename from src/include/count_sort.h rename to src/include/counting_sort.h index 222a167..0d0053d 100644 --- a/src/include/count_sort.h +++ b/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 diff --git a/src/sort.c b/src/sort.c index 418430e..b12121f 100644 --- a/src/sort.c +++ b/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(); } diff --git a/test/Makefile b/test/Makefile index fc1b030..444028d 100644 --- a/test/Makefile +++ b/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 diff --git a/test/test.c b/test/test.c index f36e428..47aa2d7 100644 --- a/test/test.c +++ b/test/test.c @@ -19,7 +19,7 @@ #include #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");