Browse Source

Merge branch 'informe' of UBB/sort into master

tags/1.0.0
Chris Cromer 9 months ago
parent
commit
57cf1f260d

+ 1
- 1
Makefile View File

@@ -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

+ 2
- 0
README.md View File

@@ -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

+ 125
- 9
doc/Informe.tex View File

@@ -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}

\newpage
\subsection{Counting Sort}
\lstinputlisting{pseudo/countingsort.txt}

\newpage
\subsection{Selection Sort}
\lstinputlisting{pseudo/selectionsort.txt}

\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. \\

\subsection{Ordenamiento por conteo}
\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. \\

\subsection{Ordenamiento por selección}
\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. \\

\section{Análisis temporal}
\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}


BIN
doc/graph.png View File


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

@@ -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

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

@@ -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

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

@@ -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

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

@@ -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

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

@@ -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

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

@@ -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

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

@@ -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

+ 1
- 1
src/bitonic_sort.c View File

@@ -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/count_sort.c → src/counting_sort.c View File

@@ -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/count_sort.h → src/include/counting_sort.h View File

@@ -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

+ 17
- 12
src/sort.c View File

@@ -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();
}


+ 1
- 1
test/Makefile View File

@@ -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


+ 4
- 4
test/test.c View File

@@ -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");

Loading…
Cancel
Save