203 lines
7.0 KiB
TeX
203 lines
7.0 KiB
TeX
\title{Tarea 1: Ordenamiento}
|
|
\author{}
|
|
\date{\today}
|
|
|
|
\documentclass[12pt]{article}
|
|
|
|
\usepackage[utf8]{inputenc} %\ This allows spanish tildes
|
|
\usepackage[spanish]{babel}
|
|
\usepackage{array}
|
|
\usepackage{adjustbox}
|
|
\usepackage{titling}
|
|
\usepackage[left=2cm,right=2cm,top=2cm,bottom=2cm,a4paper]{geometry}
|
|
\usepackage{amsmath}
|
|
|
|
\usepackage{listings}
|
|
\lstset{
|
|
basicstyle=\small\ttfamily,
|
|
columns=flexible,
|
|
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}
|
|
\usepackage{hypcap}
|
|
|
|
\pretitle{%
|
|
\begin{center}
|
|
\LARGE
|
|
\includegraphics[width=4cm]{ubblogo.png}\\[\bigskipamount]
|
|
\Large
|
|
\textbf{Análisis y Diseño de Algoritmos}\\[\smallskipamount]
|
|
}
|
|
|
|
\posttitle{\end{center}}
|
|
|
|
\begin{document}
|
|
\clearpage\maketitle
|
|
\thispagestyle{empty}
|
|
|
|
\begin{flushright}
|
|
\textbf{Integrantes:}\\
|
|
Christopher Cromer\\
|
|
Rodolfo Cuevas
|
|
\end{flushright}
|
|
|
|
\begin{flushright}
|
|
\textbf{Profesor:}\\
|
|
Pedro Rodríguez
|
|
\end{flushright}
|
|
|
|
\begin{flushright}
|
|
\textbf{Ayudantes:}\\
|
|
Carlos Faúndez\\
|
|
Xavier Canales
|
|
\end{flushright}
|
|
|
|
\newpage
|
|
|
|
\clearpage
|
|
\thispagestyle{empty}
|
|
\tableofcontents
|
|
|
|
\newpage
|
|
\pagenumbering{arabic}
|
|
\section{Pseudo código}
|
|
\subsection{Merge Sort}
|
|
\lstinputlisting{pseudo/mergesort.txt}
|
|
|
|
\newpage
|
|
\subsection{Quick Sort}
|
|
\lstinputlisting{pseudo/quicksort.txt}
|
|
|
|
\newpage
|
|
\subsection{Bubble Sort}
|
|
\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 lo mismo que su 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 caso peor es lo mismo que su caso promedio. \\
|
|
|
|
\underline{Mejor Caso:} $ \Omega(log^2(n)) $ \\
|
|
Su caso mejor es lo mismo 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 caso pero es lo mismo que su caso promedio. \\
|
|
|
|
\underline{Mejor Caso:} $ \Omega(\frac{n^2}{2}) $ \\
|
|
Su caso mejor es lo mismo que 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 caso peor es lo mismo que su caso promedio. \\
|
|
|
|
\underline{Mejor Caso:} $ \Omega(n^2) $ \\
|
|
Su caso mejor es lo mismo que 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}
|
|
|