Browse Source

finish up the informe

Chris Cromer 7 months ago
parent
commit
f03fe103c8
Signed by: Chris Cromer <chris@cromer.cl> GPG Key ID: 39CC813FF3C8708A

+ 62
- 39
doc/Informe.tex View File

@@ -67,10 +67,12 @@ Xavier Canales
67 67
 \pagenumbering{arabic}
68 68
 \section{Pseudo código}
69 69
 \subsection{Merge Sort}
70
+\lstinputlisting{pseudo/mergesort.txt}
70 71
 
71 72
 \newpage
72 73
 \subsection{Quick Sort}
73 74
 \lstinputlisting{pseudo/quicksort.txt}
75
+
74 76
 \newpage
75 77
 \subsection{Bubble Sort}
76 78
 \lstinputlisting{pseudo/bubblesort.txt}
@@ -78,73 +80,82 @@ Xavier Canales
78 80
 \newpage
79 81
 \subsection{Bitonic Sort}
80 82
 \lstinputlisting{pseudo/bitonicsort.txt}
83
+
81 84
 \newpage
82
-\subsection{Ordenamiento por conteo}
85
+\subsection{Counting Sort}
86
+\lstinputlisting{pseudo/countingsort.txt}
83 87
 
84 88
 \newpage
85
-\subsection{Ordenamiento por selección}
89
+\subsection{Selection Sort}
86 90
 \lstinputlisting{pseudo/selectionsort.txt}
91
+
87 92
 \newpage
88 93
 \section{Resultados}
89 94
 
90 95
 \subsection{Análisis temporal}
91 96
 \subsubsection{Merge Sort}
92
-Caso Promedio: $ \Theta (n log n)) $ \\
93
-en.wikipedia.org/wiki/Merge\_sort\#Analysis
94
-
95
-Peor Caso: $ O(n log n) $ \\
97
+\underline{Caso Promedio:} $ \Theta(n log n)) $ \\
98
+El caso promedio de merge sort es lo mismo que su peor caso. \\
96 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. \\
97 102
 
98
-Mejor Caso: $ \Omega (n log n)$ \\
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. \\
99 105
 
100 106
 \subsubsection{Quick Sort}
101
-Caso Promedio: $ \Theta (n(log n)) $ \\
102
-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
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. \\
103 109
 
104
-Peor Caso: $ O(n^2) $ \\
105
-El peor de los casos para el quicksort resultará cuando la elección del pivote sea el valor más pequeño del arreglo o el más grande de este mismo.
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. \\
106 112
 
107
-Mejor Caso: $ \Omega $(n log(n)) \\
108
-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
109
-\subsubsection{Bubble Sort}
110
-Caso Promedio: $ \Theta (n^2)) $ \\
111
-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 Bubble transporta los valores dentro de su ordenamiento
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. \\
112 115
 
113
-Peor Caso: $ O(n^2) $ \\
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. \\
114 119
 
120
+\underline{Peor Caso:} $ O(n^2) $ \\
121
+En el peor caso el arreglo a ordenar va a estar ordenado en forma descendente previamente. \\
115 122
 
116
-Mejor Caso: $ \Omega (n)$ \\
117
-El mejor caso para el Bubble sort será cuando el arreglo de entrada venga previamente ordenado de menor a mayor.
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. \\
118 125
 
119 126
 \subsubsection{Bitonic Sort}
120
-Caso Promedio: $\Theta(log^2(n))$ \\
121
-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
122
-
123
-Peor Caso: $O(log^2(n))$ \\
124
-
125
-Mejor Caso: $\Omega(log^2(n))$ \\
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. \\
126 129
 
127
-\subsubsection{Ordenamiento por conteo}
128
-Caso Promedio: $ \Theta (n + k)) $ \\
129
-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 analisis 
130
+\underline{Peor Caso:} $ O(log^2(n)) $ \\
131
+Su caso peor es lo mismo que su caso promedio. \\
130 132
 
131
-Peor Caso: $ O(n + k) $ \\
133
+\underline{Mejor Caso:} $ \Omega(log^2(n)) $ \\
134
+Su caso mejor es lo mismo que su caso promedio. \\
132 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. \\
133 139
 
134
-Mejor Caso: $ \Omega (n + k)$ \\
140
+\underline{Peor Caso:} $ O(\frac{n^2}{2}) $ \\
141
+Su caso pero es lo mismo que su caso promedio. \\
135 142
 
136
-\subsubsection{Ordenamiento por selección}
137
-Caso Promedio: $\Theta(n^2)$ \\
138
-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 de el arreglo para ordenar.
143
+\underline{Mejor Caso:}  $ \Omega(\frac{n^2}{2}) $ \\
144
+Su caso mejor es lo mismo que su caso promedio. \\
139 145
 
140
-Peor Caso: $O(n^2)$ \\
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. \\
141 149
 
142
-Mejor Caso: $\Omega(n^2)$
150
+\underline{Peor Caso:} $ O(n^2) $ \\
151
+Su caso peor es lo mismo que su caso promedio. \\
143 152
 
153
+\underline{Mejor Caso:} $ \Omega(n^2) $ \\
154
+Su caso mejor es lo mismo que su caso promedio. \\
144 155
 
145 156
 \newpage
146 157
 \subsection{Datos}
147
-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 un procesador AMD A12 con 4 núcleos de 2.7Ghz y 16GB de memoria RAM.
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.
148 159
 \begin{center}
149 160
 	\begin{tabular}{|c|c|c|c|c|c|c|}
150 161
 		\hline
@@ -156,11 +167,11 @@ La siguiente tabla contiene los resultados de las pruebas de los 6 algoritmos me
156 167
 		\hline
157 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] \\
158 169
 		\hline
159
-		\rule[-1ex]{0pt}{3.5ex} 1.000.000 & 0.173[s] & 0.304[s] & 1.405[s] & 1,262.000[s] & 3,026.900[s] & 3,234.700[s] \\
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] \\
160 171
 		\hline
161
-		\rule[-1ex]{0pt}{3.5ex} 5.000.000 & 2.000[s] & 1.577[s] & 7.421[s] & 31,550.000[s] & 75,672.500[s] & 80,867.500[s] \\
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] \\
162 173
 		\hline
163
-		\rule[-1ex]{0pt}{3.5ex} 10.000.000 & 2.400[s] & 3.236[s] & 18.365[s] & 126,200.000[s] & 302,690.000[s] & 323,470.000[s] \\
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] \\
164 175
 		\hline
165 176
 	\end{tabular}
166 177
 \end{center}
@@ -174,6 +185,18 @@ La siguiente tabla contiene los resultados de las pruebas de los 6 algoritmos me
174 185
 
175 186
 \newpage
176 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.
177 200
 
178 201
 \end{document}
179 202
 

BIN
doc/graph.png View File


+ 62
- 107
doc/pseudo/bitonicsort.txt View File

@@ -1,126 +1,81 @@
1
-entrada: array: arreglo de n datos: n: tamaño del arreglo
1
+entrada: array: arreglo de n datos; n: tamaño del arreglo
2 2
 salida: arreglo ordenado
3 3
 
4
-funcion potencia_de_dos(inicio n)
5
-	
6
-	si(n = 0) entonces
7
-
8
-	retornar 0
9
-
10
-	fin si
11
-	
12
-	mientras(n distinto 1) hacer
13
-		si (n % 2 distinto 0) hacer
14
-
15
-		retornar 0
16
-
17
-		fin si			
18
-	fin mientras
19
-
20
-	retornar 1
21
-
4
+funcion ordenamientobitonico(array, n)
5
+  orden(array, n, 1)
6
+  return array
22 7
 fin funcion
23 8
 
24
-inicio funcion mejor_potencia_de_2_menos_a_n(inicio n)
25
-	
26
-	inicio k = 1
27
-
28
-	mientras(k > 0 y k < n) hacer
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
29 20
 
21
+funcion mejor_potencia_de_2_menos_a_n(n)
22
+  k = 1
23
+  mientras k > 0 y k < n hacer
30 24
 	busca el numero potencia de dos mas proximo hacia abajo en n
31
-
32
-	fin mientras
33
-
34
-	retorna k
25
+  fin mientras
26
+  retorna k
35 27
 fin funcion
36 28
 
37
-funcion comparar(inicio i, inicio j, inicio dir, inicio arreglo)
38
-
39
-	temp = array[i];
40
-	array[i] = array[j];
41
-	array[j] = temp;
42
-
29
+funcion comparar(i, j, dir, array)
30
+  temp = array[i]
31
+  array[i] = array[j]
32
+  array[j] = temp
43 33
 fin funcion
44 34
 
45
-funcion unionbitonica(inicio low, inicio n, inicio dir, inicio arreglo)
46
-
47
-	inicio i
48
-	inicio k
49
-
50
-	si(n > 1) entonces 
51
-
52
-		k = n/2
53
-
54
-		para i = low hasta i < low + k con paso i = i+1
55
-
56
-		comparar(, i + k, di, arreglo)
57
-		fin para
58
-
59
-		unionbitonica(low, k, dir, arreglo)
60
-		unionbitonica(low + k, k, dir, arreglo)	
61
-
62
-	fin si	
63
-
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
64 44
 fin funcion
65 45
 
66
-funcion unionbitonico2(inicio low, inicio n, inicio dir, inicio arreglo)
67
-
68
-	inicio i
69
-	inicio k
70
-
71
-	si(n > 1) entonces
72
-
73
-		k = mejor_potencia_de_2_menos_a_n
74
-
75
-		para i = low hasta i < low + n - k con paso i = i + 1 hacer
76
-
77
-		comparar(i, i + k, dir, arreglo)
78
-
79
-		fin para 	
80
-
81
-		ordenamientobitonico2(low, k, dir, arreglo)
82
-		ordenamientobitonico2(low + k, n - k, dir, arreglo)
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)
83 54
 fin funcion
84 55
 
85
-funcion recorrerbitonico(int low, int n, int dir, int arreglo)
86
-
87
-	inicio k
88
-	si(n > 1) entonces
89
-
90
-		k = n / 2
91
-		recorrerbitonico(low, k, 1, arreglo)
92
-		recorrerbitonico(low + k, k, 0, arreglo)
93
-		unionbitonica(low, n, dir, array)
94
-
95
-	fin si
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
96 63
 fin funcion
97 64
 
98
-funcion recorrerbitonico2(int low, int n, int dir, int arreglo)
99
-
100
-	inicio k
101
-
102
-	si(n > 1) entonces
103
-		k = n / 2
104
-		recorrerbitonico2(low, k, !di, arreglo)
105
-		recorrerbitonico2(low + k, n - k, dir, arreglo)
106
-		unionbitonico2(low, n, dir, arreglo)
107
-	fin si
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
108 72
 fin funcion
109 73
 
110
-funcion orden(int arreglo, int n, int dir)
111
-
112
-	si(potencia_de_dos(n)) entonces
113
-	
114
-	recorrerbitonico(0,n,dir,arreglo)
115
-
116
-	fin si
117
-
118
-	sino
119
-		recorrerbitonico2(0, n, dir, arreglo)
120
-	fin sino	
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
121 81
 fin funcion
122
-
123
-funcion ordenamientobitonico(inicio arreglo, inicio n)
124
-
125
-	orden(arreglo, n, 1)
126
-fin funcion

+ 17
- 11
doc/pseudo/bubblesort.txt View File

@@ -1,13 +1,19 @@
1 1
 entrada: array: arreglo de elementos enteros; n: tamaño del arreglo
2
-salida: arreglo array ordenado ascendentemente.
2
+salida: arreglo array ordenado ascendentemente
3 3
 
4
-cuentaDeElementos := n
5
-repetir
6
-  haCambiado := falso
7
-  disminuir cuentaDeElementos
8
-  repetir con indice desde 1 a cuentaDeElementos
9
-    if (array en indice) > (array en (indice + 1))
10
-      intercambiar (array en indice) con (array en (indice + 1))
11
-      haCambiado := falso
12
-hasta haCambiado = verdad
13
-retorna array
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

+ 31
- 38
doc/pseudo/quicksort.txt View File

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

+ 15
- 29
doc/pseudo/selectionsort.txt View File

@@ -1,31 +1,17 @@
1
-entrada: array: arreglo de n datos: n: tamaño del arreglo
1
+entrada: array: arreglo de n datos; n: tamaño del arreglo
2 2
 salida: arreglo ordenado
3 3
 
4
-funcion selection_sort
5
-	
6
-	inicio i
7
-	inicio j
8
-	inicio temp
9
-	inicio min_idx
10
-
11
-	para i = 0 hasta i < n - 1 con paso i = i + 1 hacer
12
-
13
-	min_idx = i
14
-
15
-		para j = i + 1 hasta j < n con paso j = j + 1 hacer
16
-
17
-			si (arreglo[j] < arreglo[min_idx] hacer) hacer
18
-
19
-				min_idx = j
20
-			
21
-			fin si
22
-			
23
-		fin para
24
-
25
-		temp = arreglo[min_idx]
26
-		arreglo[min_idx] = arreglo[i]
27
-		arreglo[i] = temp
28
-
29
-	fin para
30
-
31
-fin funcion
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
- 41
doc/resultados.txt View File

@@ -1,41 +0,0 @@
1
-Quick sort
2
-	10.000     - 0.1 segundos
3
-	100.000    - 0.17 segundos
4
-	1.000.000  - 0.173 segundos
5
-	5.000.000  - 2.0 segundos
6
-	10.000.000 - 2.4 segundos
7
-
8
-Merge sort
9
-	10.000     - 0.28 segundos
10
-	100.000    - 0.30 segundos
11
-	1.000.000  - 0.304 segundos
12
-	5.000.000  - 1.577 segundos
13
-	10.000.000 - 3.236 segundos
14
-
15
-Bitonic sort
16
-	10.000     - 0.09 segundos
17
-	100.000    - 0.124 segundos
18
-	1.000.000  - 1.405 segundos
19
-	5.000.000  - 7.421 segundos
20
-	10.000.000 - 18.365 segundos
21
-
22
-Selection sort
23
-	10.000     - 0.143 segundos
24
-	100.000    - 11.645 segundos
25
-	1.000.000  - 21 minutos y 2.0 segundos                            1262 segundos
26
-	5.000.000  - 8 horas, 45 minutos y 50 segundos           teo     31550 segundos
27
-	10.000.000 - 1 day, 11 horas, 3 minutos y 20 segundos    teo    126200 segundos
28
-
29
-Count sort
30
-	10.000     - 0.258 segundos
31
-	100.000    - 30.269 segundos
32
-	1.000.000  - 50 minutos y 26.9 segundos                  teo    3026.9 segundos
33
-	5.000.000  - 21 horas, 1 minuto y 12.5 segundos          teo   75672.5 segundos
34
-	10.000.000 - 3 dias, 12 horas, 4 minutos y 50 segundos   teo  302690   segundos
35
-
36
-Bubble sort
37
-	10.000     - 0.326 segundos
38
-	100.000    - 32.347 segundos
39
-	1.000.000  - 53 minutos y 54.7 segundos                  teo    3234.7 segundos
40
-	5.000.000  - 22 horas, 27 minutos y 47.5 segundos        teo   80867.5 segundos
41
-	10.000.000 - 3 dias, 17 horas, 51 minutos y 10 segundos  teo  323470   segundos

Loading…
Cancel
Save