Browse Source

Merge branch 'informe' of UBB/sort into master

Chris Cromer 7 months ago
parent
commit
57cf1f260d

+ 1
- 1
Makefile View File

@@ -1,7 +1,7 @@
1 1
 CC=gcc
2 2
 CFLAGS=-Wall -Isrc/include -DDEBUG -g
3 3
 LDFLAGS=-lm
4
-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
4
+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
5 5
 OBJ=$(SRC:.c=.o)
6 6
 
7 7
 all: sort informe

+ 2
- 0
README.md View File

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

+ 125
- 9
doc/Informe.tex View File

@@ -16,11 +16,14 @@
16 16
 \lstset{
17 17
 	basicstyle=\small\ttfamily,
18 18
 	columns=flexible,
19
-	breaklines=true
19
+	breaklines=true,
20
+	inputencoding=utf8,
21
+	extendedchars=true,
22
+	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
20 23
 }
21 24
 
22 25
 \usepackage{hyperref}
23
-\hypersetup{pdftex,colorlinks=true,allcolors=black,bookmarks}
26
+\hypersetup{colorlinks=true,allcolors=black,bookmarks,pdftitle={Tarea 1: Ordenamiento}}
24 27
 \usepackage{hypcap}
25 28
 
26 29
 \pretitle{%
@@ -62,25 +65,138 @@ Xavier Canales
62 65
 
63 66
 \newpage
64 67
 \pagenumbering{arabic}
65
-
66
-\section{Psuedo código}
67
-
68
+\section{Pseudo código}
68 69
 \subsection{Merge Sort}
70
+\lstinputlisting{pseudo/mergesort.txt}
69 71
 
72
+\newpage
70 73
 \subsection{Quick Sort}
74
+\lstinputlisting{pseudo/quicksort.txt}
71 75
 
76
+\newpage
72 77
 \subsection{Bubble Sort}
73
-\lstinputlisting{psuedo/bubblesort.txt}
78
+\lstinputlisting{pseudo/bubblesort.txt}
74 79
 
80
+\newpage
75 81
 \subsection{Bitonic Sort}
82
+\lstinputlisting{pseudo/bitonicsort.txt}
83
+
84
+\newpage
85
+\subsection{Counting Sort}
86
+\lstinputlisting{pseudo/countingsort.txt}
87
+
88
+\newpage
89
+\subsection{Selection Sort}
90
+\lstinputlisting{pseudo/selectionsort.txt}
91
+
92
+\newpage
93
+\section{Resultados}
94
+
95
+\subsection{Análisis temporal}
96
+\subsubsection{Merge Sort}
97
+\underline{Caso Promedio:} $ \Theta(n log n)) $ \\
98
+El caso promedio de merge sort es similar a peor caso. \\
99
+
100
+\underline{Peor Caso:} $ O(n log n) $ \\
101
+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. \\
102
+
103
+\underline{Mejor Caso:} $ \Omega(n log n)$ \\
104
+En el caso mejor de merge sort, el merge sort funciona mejor cuando los datos son secuencial. \\
105
+
106
+\subsubsection{Quick Sort}
107
+\underline{Caso Promedio:} $ \Theta(n(log n)) $ \\
108
+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. \\
109
+
110
+\underline{Peor Caso:} $ O(n^2) $ \\
111
+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. \\
76 112
 
77
-\subsection{Ordenamiento por conteo}
113
+\underline{Mejor Caso:} $ \Omega(n log(n)) $ \\
114
+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. \\
78 115
 
79
-\subsection{Ordenamiento por selección}
116
+\subsubsection{Bubble Sort}
117
+\underline{Caso Promedio:} $ \Theta(n^2)) $ \\
118
+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. \\
80 119
 
81
-\section{Análisis temporal}
120
+\underline{Peor Caso:} $ O(n^2) $ \\
121
+En el peor caso el arreglo a ordenar va a estar ordenado en forma descendente previamente. \\
82 122
 
123
+\underline{Mejor Caso:} $ \Omega(n)$ \\
124
+El mejor caso para el bubble sort será cuando el arreglo de entrada venga previamente ordenado de menor a mayor. \\
125
+
126
+\subsubsection{Bitonic Sort}
127
+\underline{Caso Promedio:} $\Theta(log^2(n))$ \\
128
+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. \\
129
+
130
+\underline{Peor Caso:} $ O(log^2(n)) $ \\
131
+Su peor caso es igual que su caso promedio. \\
132
+
133
+\underline{Mejor Caso:} $ \Omega(log^2(n)) $ \\
134
+Su mejor caso es igual que su caso promedio. \\
135
+
136
+\subsubsection{Counting Sort}
137
+\underline{Caso Promedio:} $ \Theta(\frac{n^2}{2}) $ \\
138
+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. \\
139
+
140
+\underline{Peor Caso:} $ O(\frac{n^2}{2}) $ \\
141
+Su peor caso es igual a su caso promedio. \\
142
+
143
+\underline{Mejor Caso:}  $ \Omega(\frac{n^2}{2}) $ \\
144
+Su mejor caso es igual a su caso promedio. \\
145
+
146
+\subsubsection{Selection Sort}
147
+\underline{Caso Promedio:} $ \Theta(n^2) $ \\
148
+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. \\
149
+
150
+\underline{Peor Caso:} $ O(n^2) $ \\
151
+Su peor caso es igual a su caso promedio. \\
152
+
153
+\underline{Mejor Caso:} $ \Omega(n^2) $ \\
154
+Su mejor caso es igual a su caso promedio. \\
155
+
156
+\newpage
157
+\subsection{Datos}
158
+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.
159
+\begin{center}
160
+	\begin{tabular}{|c|c|c|c|c|c|c|}
161
+		\hline
162
+		\multicolumn{7}{|c|}{Algoritmos de ordenamiento} \\
163
+		\hline
164
+		\rule[-1ex]{0pt}{3.5ex} & Quick  & Merge  & Bitonic  & Selection  & Counting  & Bubble \\
165
+		\hline
166
+		\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] \\
167
+		\hline
168
+		\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] \\
169
+		\hline
170
+		\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] \\
171
+		\hline
172
+		\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] \\
173
+		\hline
174
+		\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] \\
175
+		\hline
176
+	\end{tabular}
177
+\end{center}
178
+
179
+\newpage
180
+\subsection{Gráfico}
181
+
182
+\begin{center}
183
+	\includegraphics[width=0.96\textwidth,height=0.96\textheight,keepaspectratio]{graph.png}
184
+\end{center}
185
+
186
+\newpage
83 187
 \section{Conclusiones}
188
+Basados en los resultados obtenido podemos poner los algoritmos en orden de mas rápido a menos rápido en la siguiente forma:
189
+\begin{itemize}
190
+	\setlength\itemsep{0.1em}
191
+	\item Quick Sort
192
+	\item Merge Sort
193
+	\item Bitonic Sort
194
+	\item Selection Sort
195
+	\item Counting Sort
196
+	\item Bubble Sort
197
+\end{itemize}
198
+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.
199
+Los resultados de tiempo de ejecución estaban de lo que esperábamos dado el complejidad de los algoritmos.
84 200
 
85 201
 \end{document}
86 202
 

BIN
doc/graph.png View File


+ 81
- 0
doc/pseudo/bitonicsort.txt View File

@@ -0,0 +1,81 @@
1
+entrada: array: arreglo de n datos; n: tamaño del arreglo
2
+salida: arreglo ordenado
3
+
4
+funcion ordenamientobitonico(array, n)
5
+  orden(array, n, 1)
6
+  return array
7
+fin funcion
8
+
9
+funcion potencia_de_dos(n)
10
+  si n = 0 entonces
11
+    retornar 0
12
+  fin si
13
+  mientras n distinto 1 hacer
14
+    si n es modulo de 2 entonces
15
+      retornar 0
16
+    fin si
17
+  fin mientras
18
+  retornar 1
19
+fin funcion
20
+
21
+funcion mejor_potencia_de_2_menos_a_n(n)
22
+  k = 1
23
+  mientras k > 0 y k < n hacer
24
+	busca el numero potencia de dos mas proximo hacia abajo en n
25
+  fin mientras
26
+  retorna k
27
+fin funcion
28
+
29
+funcion comparar(i, j, dir, array)
30
+  temp = array[i]
31
+  array[i] = array[j]
32
+  array[j] = temp
33
+fin funcion
34
+
35
+funcion unionbitonica(low, n, dir, array)
36
+  si n > 1 entonces
37
+    k = n / 2
38
+    para i = low hasta i < low + k con paso i = i + 1
39
+		comparar(i + k, di, array)
40
+    fin para
41
+    unionbitonica(low, k, dir, array)
42
+    unionbitonica(low + k, k, dir, array)
43
+  fin si
44
+fin funcion
45
+
46
+funcion unionbitonico2(low, n, dir, array)
47
+  si n > 1 entonces
48
+    k = mejor_potencia_de_2_menos_a_n
49
+    para i = low hasta i < low + n - k con paso i = i + 1 hacer
50
+		comparar(i, i + k, dir, array)
51
+    fin para
52
+    ordenamientobitonico2(low, k, dir, array)
53
+    ordenamientobitonico2(low + k, n - k, dir, array)
54
+fin funcion
55
+
56
+funcion recorrerbitonico(low, n, dir, array)
57
+  si n > 1 entonces
58
+    k = n / 2
59
+    recorrerbitonico(low, k, 1, array)
60
+    recorrerbitonico(low + k, k, 0, array)
61
+    unionbitonica(low, n, dir, array)
62
+  fin si
63
+fin funcion
64
+
65
+funcion recorrerbitonico2(low, n, dir, array)
66
+  si n > 1 entonces
67
+    k = n / 2
68
+    recorrerbitonico2(low, k, !di, array)
69
+    recorrerbitonico2(low + k, n - k, dir, array)
70
+    unionbitonico2(low, n, dir, array)
71
+  fin si
72
+fin funcion
73
+
74
+funcion orden(array, n, dir)
75
+  si potencia_de_dos(n) entonces
76
+    recorrerbitonico(0, n, dir, array)
77
+  fin si
78
+  sino
79
+    recorrerbitonico2(0, n, dir, array)
80
+  fin sino
81
+fin funcion

+ 19
- 0
doc/pseudo/bubblesort.txt View File

@@ -0,0 +1,19 @@
1
+entrada: array: arreglo de elementos enteros; n: tamaño del arreglo
2
+salida: arreglo array ordenado ascendentemente
3
+
4
+funcion bubblesort(array, n)
5
+  flag = 1
6
+  mientras que flag es verdad
7
+    flag = false
8
+    para i = 1 mientras que i < j con pasa i = i + 1 hacer
9
+      si array[i] < array[i - 1] entonces
10
+        temp = array[i]
11
+        array[i] = array[i - 1]
12
+        array[i - 1] = temp
13
+        flag = verdad
14
+      fin si
15
+    fin para
16
+    j = j - 1;
17
+  fin mientras
18
+  retorna array
19
+fin funcion

+ 22
- 0
doc/pseudo/countingsort.txt View File

@@ -0,0 +1,22 @@
1
+entrada: array: arreglo de elementos enteros; n: tamaño del arreglo
2
+salida: arreglo array ordenado ascendentemente
3
+
4
+funcion countingsort(array, n)
5
+  para i = 0 mientras que i < n con paso i = i + 1 hacer
6
+    count[i] = 0
7
+  fin para
8
+  para i = 0 mientras que i < n - 1 con paso i = i + 1 hacer
9
+    para j = i + 1 mientras que j < n con paso j = j + 1 hacer
10
+      si array[i] < array[j] entonces
11
+        count[j] = count[j] + 1
12
+      sino
13
+        count[i] = count[i] + 1
14
+      fin si
15
+    fin para
16
+  fin para
17
+
18
+  para i = 0 mientras que i < n con paso i = i + 1 hacer
19
+    newarray[count[i]] = array[i]
20
+  }
21
+  retorna newarray
22
+fin funcion

+ 43
- 0
doc/pseudo/mergesort.txt View File

@@ -0,0 +1,43 @@
1
+entrada: array: arreglo de n datos; n: tamaño del arreglo
2
+salida: arreglo ordenado
3
+
4
+funcion mergesort(array, n)
5
+  correr_mergesort(array, 0, n - 1);
6
+  retorna array
7
+fin funcion
8
+
9
+funcion correr_mergesort(array, izquerda, derecha)
10
+  si izquerda != derecha entonces
11
+    medio = (izquerda + derecha) / 2
12
+    correr_mergesort(array, izquerda, medio)
13
+    correr_mergesort(array, medio + 1, derecha)
14
+    unir(array, izquerda, medio + 1, derecha)
15
+  fin si
16
+fin funcion
17
+
18
+funcion unir(array, previo_izquerda, previo_medio, derecha)
19
+  i = 0
20
+  izquerda = previo_izquerda
21
+  medio = previo_medio - 1
22
+  far_derecha = derecha - izquerda + 1
23
+
24
+  mientras que previo_izquerda <= medio y previo_medio <= derecha hacer
25
+    si array[previo_izquerda] < array[previo_medio] entonces
26
+      temp[i++] = array[previo_izquerda++]
27
+    sino
28
+      temp[i++] = array[previo_medio++]
29
+    fin si
30
+  fin mientras
31
+
32
+  mientras que previo_izquerda <= medio hacer
33
+    temp[i++] = array[previo_izquerda++]
34
+  fin mientras
35
+
36
+  mientras que previo_medio <= derecha hacer
37
+    temp[i++] = array[previo_medio++]
38
+  fin mientras
39
+
40
+  para i = 0 mientras que i < far_derecha con paso i = i + 1 hacer
41
+    array[izquerda + i] = temp[i]
42
+  fin para
43
+fin funcion

+ 33
- 0
doc/pseudo/quicksort.txt View File

@@ -0,0 +1,33 @@
1
+entrada: array: arreglo de n datos; n: tamaño del array
2
+salida: arreglo ordenado
3
+
4
+funcion quick_sort(array, n)
5
+  si n < 2 entonces
6
+    retorna
7
+  fin si
8
+
9
+  pivote = array[n / 2]
10
+
11
+  para i = 0 y j = n - 1 con paso i = i + 1 y j = j - 1 hacer
12
+    mientras que array[i] < pivote hacer
13
+      i = i + 1
14
+    fin mientras
15
+
16
+    mientras que array[j] > pivote hacer
17
+      j = j - 1
18
+    fin mientras
19
+
20
+    si i >= j entonces
21
+      break
22
+    fin si
23
+
24
+    temp = array[i]
25
+    array[i] = array[j]
26
+    array[j] = temp
27
+  fin para
28
+
29
+  quick_sort(array, i)
30
+  quick_sort(array + i, n - i)
31
+
32
+  retorna array
33
+fin funcion

+ 17
- 0
doc/pseudo/selectionsort.txt View File

@@ -0,0 +1,17 @@
1
+entrada: array: arreglo de n datos; n: tamaño del arreglo
2
+salida: arreglo ordenado
3
+
4
+funcion selection_sort(array, n)
5
+  para i = 0 hasta i < n - 1 con paso i = i + 1 hacer
6
+    min_idx = i
7
+    para j = i + 1 hasta j < n con paso j = j + 1 hacer
8
+      si array[j] < array[min_idx] entonces
9
+        min_idx = j
10
+      fin si
11
+    fin para
12
+    temp = array[min_idx]
13
+    array[min_idx] = array[i]
14
+    array[i] = temp
15
+  fin para
16
+  retorna array
17
+fin funcion

+ 0
- 9
doc/psuedo/bubblesort.txt View File

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

+ 1
- 1
src/bitonic_sort.c View File

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

src/count_sort.c → src/counting_sort.c View File

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

src/include/count_sort.h → src/include/counting_sort.h View File

@@ -13,7 +13,7 @@
13 13
  * 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.
14 14
  */
15 15
 
16
-#ifndef _SORT_COUNT
17
-	#define _SORT_COUNT
18
-	void count_sort(int *array, int n);
16
+#ifndef _SORT_COUNTING
17
+	#define _SORT_COUNTING
18
+	void counting_sort(int *array, int n);
19 19
 #endif

+ 17
- 12
src/sort.c View File

@@ -22,7 +22,7 @@
22 22
 #include "random.h"
23 23
 #include "timer.h"
24 24
 #include "bubble_sort.h"
25
-#include "count_sort.h"
25
+#include "counting_sort.h"
26 26
 #include "quick_sort.h"
27 27
 #include "bitonic_sort.h"
28 28
 #include "selection_sort.h"
@@ -49,7 +49,7 @@ void print_usage() {
49 49
 	fprintf(stdout, "  -q, --quick                usar quick sort\n");
50 50
 	fprintf(stdout, "  -b, --bubble               usar bubble sort\n");
51 51
 	fprintf(stdout, "  -B, --bitonic              usar bitonic sort\n");
52
-	fprintf(stdout, "  -c, --count                usar ordenamiento por conteo\n");
52
+	fprintf(stdout, "  -c, --counting             usar ordenamiento por conteo\n");
53 53
 	fprintf(stdout, "  -s, --selection            usar ordenamiento por selección\n");
54 54
 	fprintf(stdout, "  -n, --n=N                  la cantidad de elementos a ordenar, la\n");
55 55
 	fprintf(stdout, "                             cantidad predeterminado es 10\n");
@@ -57,6 +57,7 @@ void print_usage() {
57 57
 	fprintf(stdout, "                             elementos a ordenar, sin esta opción los\n");
58 58
 	fprintf(stdout, "                             valores son elegido por el programa al azar\n");
59 59
 	fprintf(stdout, "  -i, --imprimir             imprimir el array antes y despues de ordenar\n");
60
+	fprintf(stdout, "  -h, --help                 mostrar como usar el programa\n");
60 61
 	fprintf(stdout, "  -v, --version              mostrar la versión del programa\n");
61 62
 }
62 63
 
@@ -182,7 +183,7 @@ int main (int argc, char **argv) {
182 183
 	int quick = 0;
183 184
 	int bubble = 0;
184 185
 	int bitonic = 0;
185
-	int count = 0;
186
+	int counting = 0;
186 187
 	int selection = 0;
187 188
 	int opt;
188 189
 	int long_index = 0;
@@ -192,11 +193,12 @@ int main (int argc, char **argv) {
192 193
 		{"quick",		no_argument,		0,	'q'},
193 194
 		{"bubble",		no_argument,		0,	'b'},
194 195
 		{"bitonic",		no_argument,		0,	'B'},
195
-		{"count",		no_argument,		0,	'c'},
196
+		{"counting",	no_argument,		0,	'c'},
196 197
 		{"selection",	no_argument,		0,	's'},
197 198
 		{"n",			required_argument,	0,	'n'},
198 199
 		{"elegir",		no_argument,		0,	'e'},
199 200
 		{"imprimir",	no_argument,		0,	'i'},
201
+		{"help",		no_argument,		0,  'h'},
200 202
 		{"version",		no_argument,		0,	'v'},
201 203
 		{0, 0, 0, 0}
202 204
 	};
@@ -206,14 +208,14 @@ int main (int argc, char **argv) {
206 208
 		return 0;
207 209
 	}
208 210
 
209
-	while ((opt = getopt_long(argc, argv, "amqbBcsn:eiv", long_options, &long_index)) != -1) {
211
+	while ((opt = getopt_long(argc, argv, "amqbBcsn:eihv", long_options, &long_index)) != -1) {
210 212
 		switch (opt) {
211 213
 			case 'a':
212 214
 				merge = 1;
213 215
 				quick = 1;
214 216
 				bubble = 1;
215 217
 				bitonic = 1;
216
-				count = 1;
218
+				counting = 1;
217 219
 				selection = 1;
218 220
 				break;
219 221
 			case 'm':
@@ -229,7 +231,7 @@ int main (int argc, char **argv) {
229 231
 				bitonic = 1;
230 232
 				break;
231 233
 			case 'c':
232
-				count = 1;
234
+				counting = 1;
233 235
 				break;
234 236
 			case 's':
235 237
 				selection = 1;
@@ -281,6 +283,9 @@ int main (int argc, char **argv) {
281 283
 			case 'i':
282 284
 				imprimir = 1;
283 285
 				break;
286
+			case 'h':
287
+				print_usage();
288
+				return 0;
284 289
 			case 'v':
285 290
 				printf("sort versión: %s\n", SORT_VERSION);
286 291
 				return 0;
@@ -291,7 +296,7 @@ int main (int argc, char **argv) {
291 296
 		}
292 297
 	}
293 298
 
294
-	if (!merge && !quick && !bubble && !bitonic && !count && !selection) {
299
+	if (!merge && !quick && !bubble && !bitonic && !counting && !selection) {
295 300
 		fprintf(stderr, "Error: No se seleccionó un algoritmo valido!\n");
296 301
 		print_usage();
297 302
 		return 4;
@@ -346,10 +351,10 @@ int main (int argc, char **argv) {
346 351
 		end_sort();
347 352
 	}
348 353
 
349
-	// O(n^2)
350
-	if (count) {
351
-		start_sort("Count sort corriendo... ", n);
352
-		count_sort(work_array, n);
354
+	// O((1/2) * n^2 - (1/2) * n)
355
+	if (counting) {
356
+		start_sort("Counting sort corriendo... ", n);
357
+		counting_sort(work_array, n);
353 358
 		end_sort();
354 359
 	}
355 360
 

+ 1
- 1
test/Makefile View File

@@ -3,7 +3,7 @@ CFLAGS=-Wall -I../src/include -DDEBUG -g
3 3
 SRC=test.c
4 4
 OBJ=$(SRC:.c=.o)
5 5
 
6
-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
6
+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
7 7
 
8 8
 all: test
9 9
 

+ 4
- 4
test/test.c View File

@@ -19,7 +19,7 @@
19 19
 #include <unistd.h>
20 20
 #include "random.h"
21 21
 #include "bubble_sort.h"
22
-#include "count_sort.h"
22
+#include "counting_sort.h"
23 23
 #include "selection_sort.h"
24 24
 #include "bitonic_sort.h"
25 25
 #include "merge_sort.h"
@@ -124,12 +124,12 @@ int main(int argc, char **argv) {
124 124
 		passed++;
125 125
 	}
126 126
 
127
-	// Test count sort
127
+	// Test counting sort
128 128
 	pass = 1;
129 129
 	memcpy(test_array, test_case, sizeof(int) * n);
130
-	fprintf(stdout, "\tcount sort: ");
130
+	fprintf(stdout, "\tcounting sort: ");
131 131
 	fflush(stdout);
132
-	count_sort(test_array, n);
132
+	counting_sort(test_array, n);
133 133
 	for (i = 0; i < n; i++) {
134 134
 		if (test_array[i] != qarray[i]) {
135 135
 			fprintf(stdout, "fail\n");

Loading…
Cancel
Save