Estructura de datos III
|
|
- Ana María Gallego Rey
- hace 7 años
- Vistas:
Transcripción
1 TP 1: Algoritmos de ordenamiento Página 1 de 33
2 Autor: Sede: San Isidro Página 2 de 33
3 Resumen Algoritmos de ordenamiento El siguiente trabajo desarrolla el tema de la performance en distintos algoritmos de ordenamiento y presenta una comparativa de cada uno de ellos, como también el órden de complejidad de los mismos. Los algoritmos analizados son: Bubble sort Selection sort Insertion sort Shell sort Heap sort Merge sort Quick sort Las implementaciones de los algoritmos han sido realizadas en c++. Página 3 de 33
4 Indice Introducción... 4 Análisis de los algoritmos... 5 Bubble sort... 5 Selection sort... 6 Insertion sort... 7 Merge sort... 9 Quick sort Heap Sort Shell sort Conclusiones Apéndice Apéndice 1 - Código fuente del Trabajo Práctico Apendice 2 - Análisis de Algoritmos Apendice 3 - Referencias Página 4 de 33
5 Introducción. Uno de los problemas fundamentales en la ciencia de la computación es ordenar una lista de items. Existen una infinidad de métodos de ordenamiento, algunos son simples e intuitivos, como el bubble sort, y otros como son extremadamente complicados, pero producen los resultados mucho más rápido. En este trabajo se presentan los algoritmos de ordenamiento más comunes, entre los cuales están los siguientes: Bubble sort, Heap sort, Insertion sort, Merge sort, Quick sort, Selection sort y Shell sort. Los algoritmos de ordenamiento pueden ser divididos en dos clases de acuerdo a la complejidad de los mismos. La complejidad del algoritmo se denota según la notación Big-O. Por ejemplo, O(n) significa que el algoritmo tiene una complejidad lineal. En otras palabras, toma 10 veces más tiempo en operar un set de 100 datos que en hacerlo con un set de 10 items. Si la complejidad fuera O(n 2 ) entonces tomaría 100 veces más tiempo en operar 100 items que en hacerlo con 10. Adicionalmente a la compejidad de los algoritmos, la velocidad de ejecución puede cambiar de acuerdo al tipo de dato a ordenar, es por ello que es conveniente comprar los algoritmos contra datos empíricos. Éstos datos empíricos se deben elaborar tomando la media de tiempo de ejecución en un conjunto de corridas y con datos del mismo tipo. En este trabajo se ejecutaron 10 veces cada algoritmo de ordenamiento con un set de datos de tipo entero de c++. Se realiza también una comprativa con otros tipos de datos como ser el long y el char para todos los algoritmos y luego se los compara entre cada uno de ellos. En el gráfico siguiente se puede ver el tiempo de ejecución del algoritmo en función de la cantidad de elementos, se puede observar que si los elementos a ordenar son pocos, menos de 1000 casi todos los tienen el mismo tiempo de respuesta, pero si la cantidad de datos aumenta los tiempos de respuesta van cambiando drásticamente entre cada uno de los ellos, y para una cantidad de datos de 8000 ya se puede determinar que el peor algoritmo es el bubble sort, mientras que el mejor es el Heap sort. Página 5 de 33
6 Comparativa de algoritmos Tiempo Elementos Poly. ( Bubble) Poly. ( Insertion) Poly. ( Selection) Poly. ( Quick) Poly. ( Shell) Poly. ( Heap) Poly. ( Merge) Análisis de los algoritmos Bubble sort Este es el método más simple y antiguo para ordenar un conjunto de datos, es también el más lento. El algoritmo bubble sort tiene dos bucles for internos que recorren el vector comparando el elemento j-esimo-1 con el elemento con el j-esimo elemento y en caso de que este sea mayor hace un cambio de los elementos. Al tener dos bucles internos el comportamiento es en general O(n 2 ), y en las mejores condiciones se comporta como O(n). Bubble sort Tiempo Elementos Página 6 de 33
7 Como funciona Consiste en comparar pares de elementos adyacentes e intercambiarlos entre sí hasta que estén todos ordenados. Con el array anterior, 40,21,4,9,10,35: Primera pasada: 21,40,4,9,10,35 <-- Se cambia el 21 por el ,4,40,9,10,35 <-- Se cambia el 40 por el 4. 21,4,9,40,10,35 <-- Se cambia el 9 por el ,4,9,10,40,35 <-- Se cambia el 40 por el ,4,9,10,35,40 <-- Se cambia el 35 por el 40. Segunda pasada: 4,21,9,10,35,40 <-- Se cambia el 21 por el 4. 4,9,21,10,35,40 <-- Se cambia el 9 por el 21. 4,9,10,21,35,40 <-- Se cambia el 21 por el 10. Ya están ordenados, pero para comprobarlo habría que acabar esta segunda comprobación y hacer una tercera. Código fuente void bubblesort (int numbers[], int array_size) int i, j, temp; for (i = (array_size - 1); i >= 0; i--) for (j = 1; j <= i; j++) if (numbers[j-1] > numbers[j]) temp = numbers[j-1]; numbers[j-1] = numbers[j]; numbers[j] = temp; Selection sort Este algoritmo trabaja seleccionando el item más pequeño a ser ordenado que aún esta en la lista, y luego haciendo un intercambio con el elemento en la siguiente posición. La complejidad de este algoritmo es O(n 2 ). Página 7 de 33
8 Selection sort Tiempo Elementos Como funciona. Este método consiste en buscar el elemento más pequeño del array y ponerlo en primera posición; luego, entre los restantes, se busca el elemento más pequeño y se coloca en segudo lugar, y así sucesivamente hasta colocar el último elemento. Por ejemplo, si tenemos el array 40,21,4,9,10,35, los pasos a seguir son: 4,21,40,9,10,35 <-- Se coloca el 4, el más pequeño, en primera posición : se cambia el 4 por el 40. 4,9,40,21,10,35 <-- Se coloca el 9, en segunda posición: se cambia el 9 por el 21. 4,9,10,21,40,35 <-- Se coloca el 10, en tercera posición: se cambia el 10 por el 40. 4,9,10,21,40,35 <-- Se coloca el 21, en tercera posición: ya está colocado. 4,9,10,21,35,40 <-- Se coloca el 35, en tercera posición: se cambia el 35 por el 40. Código fuente. void selectionsort(int numbers[], int array_size) int i, j; int min, temp; for (i = 0; i < array_size-1; i++) min = i; for (j = i+1; j < array_size; j++) if (numbers[j] < numbers[min]) min = j; Página 8 de 33
9 temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; Insertion sort El insertion sort trabaja insertando el item en su lugar correspondiente al final de la lista. Como el bubble sort, éste algoritmo se comporta como O(n 2 ), pero a pesar de tener el misma complejidad, este algoritmo es casi el doble más eficiente que el bubble sort. Insertion sort Tiempo Elementos Como funciona. En este método lo que se hace es tener una sublista ordenada de elementos del array e ir insertando el resto en el lugar adecuado para que la sublista no pierda el orden. La sublista ordenada se va haciendo cada vez mayor, de modo que al final la lista entera queda ordenada. Para el ejemplo 40,21,4,9,10,35, se tiene: 40,21,4,9,10,35 <-- La primera sublista ordenada es 40. Insertamos el 21: 40,40,4,9,10,35 <-- aux=21; 21,40,4,9,10,35 <-- Ahora la sublista ordenada es 21,40. Insertamos el 4: 21,40,40,9,10,35 <-- aux=4; Página 9 de 33
10 21,21,40,9,10,35 <-- aux=4; 4,21,40,9,10,35 <-- Ahora la sublista ordenada es 4,21,40. Insertamos el 9: 4,21,40,40,10,35 <-- aux=9; 4,21,21,40,10,35 <-- aux=9; 4,9,21,40,10,35 <-- Ahora la sublista ordenada es 4,9,21,40. Insertamos el 10: 4,9,21,40,40,35 <-- aux=10; 4,9,21,21,40,35 <-- aux=10; 4,9,10,21,40,35 <-- Ahora la sublista ordenada es 4,9,10,21,40. Y por último insertamos el 35: 4,9,10,21,40,40 <-- aux=35; 4,9,10,21,35,40 <-- El array está ordenado. En el peor de los casos, el número de comparaciones que hay que realizar es de N*(N+1)/2-1, lo que nos deja un tiempo de ejecución en O(n2). En el mejor caso (cuando la lista ya estaba ordenada), el número de comparaciones es N-2. Todas ellas son falsas, con lo que no se produce ningún intercambio. El tiempo de ejecución está en O(n). El caso medio dependerá de cómo están inicialmente distribuidos los elementos. Vemos que cuanto más ordenada esté inicialmente más se acerca a O(n) y cuanto más desordenada, más se acerca a O(n2). El peor caso es igual que en los métodos de burbuja y selección, pero el mejor caso es lineal, algo que no ocurría en éstos, con lo que para ciertas entradas podemos tener ahorros en tiempo de ejecución. Código fuente. void insertionsort(int numbers[], int array_size) int i, j, index; for (i=1; i < array_size; i++) index = numbers[i]; j = i; while ((j > 0) && (numbers[j-1] > index)) numbers[j] = numbers[j-1]; j = j - 1; numbers[j] = index; Página 10 de 33
11 Merge sort El merge sort divide la lista a ser ordenada en dos mitades iguales y las pone en arrays separadas. Cada array es ordenado recursivamente, y luego se juntan en el array final. Este algoritmo tiene un comportamiento de O(n log n). Implementaciones elementales del merge sort hacen uso de tres arrays, uno para cada mitad y uno para almacenar el resultado final. El algoritmo aqui presentado mezcla in situ los dos arrays para presentar el resultado en uno de ellos, por lo cual solo utiliza dos arrays. Merge sort Tiempo Elementos Como funciona. Consta de dos partes, una parte de intercalación de listas y otra de divide y vencerás. - Primera parte: Cómo intercalar dos listas ordenadas en una sola lista ordenada de forma eficiente? Suponemos que se tienen estas dos listas de enteros ordenadas ascendentemente: lista 1: 1 -> 3 -> 5 -> 6 -> 8 -> 9 lista 2: 0 -> 2 -> 6 -> 7 -> 10 Tras mezclarlas queda: lista: 0 -> 1 -> 2 -> 3 -> 5 -> 6 -> 6 -> 7 -> 8 -> 9 -> 10 Esto se puede realizar mediante un único recorrido de cada lista, mediante dos punteros que recorren cada una. En el ejemplo anterior se insertan en este orden - salvo los dos 6 que puede variar según la implementación-: 0 (lista 2), el 1 (lista 1), el 2 (lista 2), el 3, 5 y 6 (lista 1), el 6 y 7 (lista 2), el 8 y 9 (lista 1), y por llegar al final de la lista 1, se introduce directamente todo lo que quede de la lista 2, que es el Página 11 de 33
12 10. - Segunda parte: divide y vencerás. Se separa la lista original en dos trozos del mismo tamaño (salvo listas de longitud impar) que se ordenan recursivamente, y una vez ordenados se fusionan obteniendo una lista ordenada. Como todo algoritmo basado en divide y vencerás tiene un caso base y un caso recursivo. * Caso base: cuando la lista tiene 1 ó 0 elementos (0 se da si se trata de ordenar una lista vacía). Se devuelve la lista tal cual está. * Caso recursivo: cuando la longitud de la lista es de al menos 2 elementos. Se divide la lista en dos trozos del mismo tamaño que se ordenan recursivamente. Una vez ordenado cada trozo, se fusionan y se devuelve la lista resultante. El esquema es el siguiente: Ordenar(lista L) inicio si tamaño de L es 1 o 0 entonces devolver L si tamaño de L es >= 2 entonces separar L en dos trozos: L1 y L2. L1 = Ordenar(L1) L2 = Ordenar(L2) L = Fusionar(L1, L2) devolver L fin El algoritmo funciona y termina porque llega un momento en el que se obtienen listas de 2 ó 3 elementos que se dividen en dos listas de un elemento (1+1=2) y en dos listas de uno y dos elementos (1+2=3, la lista de 2 elementos se volverá a dividir), respectivamente. Por tanto se vuelve siempre de la recursión con listas ordenadas (pues tienen a lo sumo un elemento) que hacen que el algoritmo de fusión reciba siempre listas ordenadas. Se incluye un ejemplo explicativo donde cada sublista lleva una etiqueta identificativa. Dada: 3 -> 2 -> 1 -> 6 -> 9 -> 0 -> 7 -> 4 -> 3 -> 8 (lista original) se divide en: 3 -> 2 -> 1 -> 6 -> 9 (lista 1) 0 -> 7 -> 4 -> 3 -> 8 (lista 2) se ordena recursivamente cada lista: 3 -> 2 -> 1 -> 6 -> 9 (lista 1) se divide en: Página 12 de 33
13 3 -> 2 -> 1 (lista 11) 6 -> 9 (lista 12) se ordena recursivamente cada lista: 3 -> 2 -> 1 (lista 11) se divide en: 3 -> 2 (lista 111) 1 (lista 112) se ordena recursivamente cada lista: 3 -> 2 (lista 111) se divide en: 3 (lista 1111, que no se divide, caso base). Se devuelve 3 2 (lista 1112, que no se divide, caso base). Se devuelve 2 se fusionan y queda: 2 -> 3. Se devuelve 2 -> 3 1 (lista 112) 1 (lista 1121, que no se divide, caso base). Se devuelve 1 se fusionan y queda: 1 -> 2 -> 3 (lista 11). Se devuelve 1 -> 2 -> 3 6 -> 9 (lista 12) se divide en: 6 (lista 121, que no se divide, caso base). Se devuelve 6 9 (lista 122, que no se divide, caso base). Se devuelve 9 se fusionan y queda: 6 -> 9 (lista 12). Se devuelve 6 -> 9 se fusionan y queda: 1 -> 2 -> 3 -> 6 -> 9. Se devuelve 1 -> 2 -> 3 -> 6 -> 9 0 -> 7 -> 4 -> 3 -> 8 (lista 2) tras repetir el mismo procedimiento se devuelve 0 -> 3 -> 4 -> 7 -> 8 se fusionan 1-2 y queda: 0 -> 1 -> 2 -> 3 -> 3 -> 4 -> 6 -> 7 -> 8 -> 9, que se devuelve y se termina. - Segunda parte: divide y vencerás. Se separa la lista original en dos trozos del mismo tamaño (salvo listas de longitud impar) que se ordenan recursivamente, y una vez ordenados se fusionan obteniendo una lista ordenada. Como todo algoritmo basado en divide y vencerás tiene un caso base y un caso recursivo. * Caso base: cuando la lista tiene 1 ó 0 elementos (0 se da si se trata de ordenar una lista vacía). Se devuelve la lista tal cual está. Página 13 de 33
14 * Caso recursivo: cuando la longitud de la lista es de al menos 2 elementos. Se divide la lista en dos trozos del mismo tamaño que se ordenan recursivamente. Una vez ordenado cada trozo, se fusionan y se devuelve la lista resultante. Código fuente. void mergesort(int numbers[], int temp[], int array_size) m_sort(numbers, temp, 0, array_size - 1); void m_sort(int numbers[], int temp[], int left, int right) int mid; if (right > left) mid = (right + left) / 2; m_sort(numbers, temp, left, mid); m_sort(numbers, temp, mid+1, right); merge(numbers, temp, left, mid+1, right); void merge(int numbers[], int temp[], int left, int mid, int right) int i, left_end, num_elements, tmp_pos; left_end = mid - 1; tmp_pos = left; num_elements = right - left + 1; while ((left <= left_end) && (mid <= right)) if (numbers[left] <= numbers[mid]) temp[tmp_pos] = numbers[left]; tmp_pos = tmp_pos + 1; left = left +1; else temp[tmp_pos] = numbers[mid]; tmp_pos = tmp_pos + 1; mid = mid + 1; while (left <= left_end) temp[tmp_pos] = numbers[left]; Página 14 de 33
15 Quick sort left = left + 1; tmp_pos = tmp_pos + 1; while (mid <= right) temp[tmp_pos] = numbers[mid]; mid = mid + 1; tmp_pos = tmp_pos + 1; for (i=0; i <= num_elements; i++) numbers[right] = temp[right]; right = right - 1; El Quick sort es un algoritmo del estilo divide y venceras. Es bastante más rápido que el merge sort. El algoritmo de recursion consiste en una serie de cuatro pasos: 1. Si hay menos de un elemento a ser ordenado retorna inmediatamente. 2. Tomar un elemento del vector que sirve como Pivot 3. Dividir el array en dos partes, una con los elementos mayores y una con los elementos menores al pivot. 4. Repetir recursivamente el algoritmo para las dos mitades del array original. La eficiencia de este algoritmo es impactama mayormente por la selección del elemento que sera tomado como pivot. En el peor caso, el comportamiento es de la forma O(n 2 ), y ocurre cuando la lista esta ordenada. Si el elemento utilizado como pivot se selecciona de forma random, el comportamiento se parece a O(n log n). Página 15 de 33
16 Quick sort Tiempo Elementos Como funciona. Este método se basa en la táctica "divide y vencerás", que consiste en ir subdividiendo el array en arrays más pequeños, y ordenar éstos. Para hacer esta división, se toma un valor del array como pivote, y se mueven todos los elementos menores que este pivote a su izquierda, y los mayores a su derecha. A continuación se aplica el mismo método a cada una de las dos partes en las que queda dividido el array. Normalmente se toma como pivote el primer elemento de array, y se realizan dos búsquedas: una de izquierda a derecha, buscando un elemento mayor que el pivote, y otra de derecha a izquierda, buscando un elemento menor que el pivote. Cuando se han encontrado los dos, se intercambian, y se sigue realizando la búsqueda hasta que las dos búsquedas se encuentran.por ejemplo, para dividir el array 21,40,4,9,10,35, los pasos serían: 21,40,4,9,10,35 <-- se toma como pivote el 21. La búsqueda de izquierda a derecha encuentra el valor 40, mayor que pivote, y la búsqueda de derecha a izquierda encuentra el valor 10, menor que el pivote. Se intercambian:21,10,4,9,40,35 <-- Si seguimos la búsqueda, la primera encuentra el valor 40, y la segunda el valor 9, pero ya se han cruzado, así que paramos. Para terminar la división, se coloca el pivote en su lugar (en el número encontrado por la segunda búsqueda, el 9, quedando: 9,10,4,21,40,35 <-- Ahora tenemos dividido el array en dos arrays más pequeños: el 9,10,4 y el 40,35, y se repetiría el mismo proceso. Código fuente. void quicksort(int numbers[], int array_size) Página 16 de 33
17 Heap Sort q_sort(numbers, 0, array_size - 1); void q_sort(int numbers[], int left, int right) int pivot, l_hold, r_hold; l_hold = left; r_hold = right; pivot = numbers[left]; while (left < right) while ((numbers[right] >= pivot) && (left < right)) right--; if (left!= right) numbers[left] = numbers[right]; left++; while ((numbers[left] <= pivot) && (left < right)) left++; if (left!= right) numbers[right] = numbers[left]; right--; numbers[left] = pivot; pivot = left; left = l_hold; right = r_hold; if (left < pivot) q_sort(numbers, left, pivot-1); if (right > pivot) q_sort(numbers, pivot+1, right); El heap sort tiene un comportamiento del tipo O(n log n), pero a diferencia de los algoritmos merge y quick sort este no requiere recursión masiva o múltiples arrays para trabajar. El heap sort comienza construyendo un heap del set de datos, y luego remueve los items más grandes poniendolos al final del array ordenado. Luego de eliminar los items más grandes, reconstruye el heap y remueve los elementos más grandes nuevamente. Esto lo repite hasta que no queden elementos en el heap y el heap de items ordenados este lleno. Página 17 de 33
18 Heap sort Tiempo Elementos Como funciona. No es propiamente un método de ordenación, consiste en la unión de dos arrays ordenados de modo que la unión esté también ordenada. Para ello, basta con recorrer los arrays de izquierda a derecha e ir tomando el menor de los dos elementos, de forma que sólo aumenta el contador del array del que sale el elemento siguiente para el array-suma. Si quisiéramos sumar los arrays 1,2,4 y 3,5,6, los pasos serían: Inicialmente: i1=0, i2=0, is=0. Primer elemento: mínimo entre 1 y 3 = 1. Suma=1. i1=1, i2=0, is=1. Segundo elemento: mínimo entre 2 y 3 = 2. Suma=1,2. i1=2, i2=0, is=2. Tercer elemento: mínimo entre 4 y 3 = 3. Suma=1,2,3. i1=2, i2=1, is=3. Cuarto elemento: mínimo entre 4 y 5 = 4. Suma=1,2,3,4. i1=3, i2=1, is=4. Como no quedan elementos del primer array, basta con poner los elementos que quedan del segundo array en la suma: Código fuente. void heapsort(int numbers[], int array_size) int i, temp; for (i = (array_size / 2)-1; i >= 0; i--) siftdown(numbers, i, array_size); for (i = array_size-1; i >= 1; i--) temp = numbers[0]; numbers[0] = numbers[i]; Página 18 de 33
19 Shell sort numbers[i] = temp; siftdown(numbers, 0, i-1); void siftdown(int numbers[], int root, int bottom) int done, maxchild, temp; done = 0; while ((root*2 <= bottom) && (!done)) if (root*2 == bottom) maxchild = root * 2; else if (numbers[root * 2] > numbers[root * 2 + 1]) maxchild = root * 2; else maxchild = root * 2 + 1; if (numbers[root] < numbers[maxchild]) temp = numbers[root]; numbers[root] = numbers[maxchild]; numbers[maxchild] = temp; root = maxchild; else done = 1; Inventado en 1959, éste algoritmo es el más eficiente de los del tipo O(n 2 ). Pero el Shell es también el más complicado de los algoritmos de este tipo. El algoritmo realiza multiples pases a través de la lista, y en cada pasada ordena un numero igual de items. El tamaño del set de datos (también llamado distancia o intervalo) a ser ordenado va creciendo a medida que el algoritmo recorre el array hasta que finalmente el set esta compuesto por todo el array en si mismo. El tamaño del set de datos usado tiene un impacto significativo en la eficiencia del algoritmo. Algunas implementaciones de este algoritmo tienen una función que permite calcular el tamaño óptimo del set de datos para un array determinado. Página 19 de 33
20 Shell sort Tiempo Elementos Como funciona Es una mejora del método de inserción directa, utilizado cuando el array tiene un gran número de elementos. En este método no se compara a cada elemento con el de su izquierda, como en el de inserción, sino con el que está a un cierto número de lugares (llamado salto) a su izquierda. Este salto es constante, y su valor inicial es N/2 (siendo N el número de elementos, y siendo división entera). Se van dando pasadas hasta que en una pasada no se intercambie ningún elemento de sitio. Entonces el salto se reduce a la mitad, y se vuelven a dar pasadas hasta que no se intercambie ningún elemento, y así sucesivamente hasta que el salto vale 1. Por ejemplo, lo pasos para ordenar el array 40,21,4,9,10,35 mediante el método de Shell serían: Salto=3: Primera pasada: 9,21,4,40,10,35 <-- se intercambian el 40 y el 9. 9,10,4,40,21,35 <-- se intercambian el 21 y el 10. Salto=1: Primera pasada: 9,4,10,40,21,35 <-- se intercambian el 10 y el 4. 9,4,10,21,40,35 <-- se intercambian el 40 y el 21. 9,4,10,21,35,40 <-- se intercambian el 35 y el 40. Segunda pasada: 4,9,10,21,35,40 <-- se intercambian el 4 y el 9. Con sólo 6 intercambios se ha ordenado el array, cuando por inserción se necesitaban muchos más. Código fuente Página 20 de 33
21 void shellsort(int numbers[], int array_size) int i, j, increment, temp; increment = 3; while (increment > 0) for (i=0; i < array_size; i++) j = i; temp = numbers[i]; while ((j >= increment) && (numbers[j-increment] > temp)) numbers[j] = numbers[j - increment]; j = j - increment; numbers[j] = temp; if (increment/2!= 0) increment = increment/2; else if (increment == 1) increment = 0; else increment = 1; Página 21 de 33
22 Conclusiones Los algoritmos comunes de ordenamiento pueden dividirse en dos clases, según su orden de complejidad. Por un lado están los algoritmos de complejidad cuadrática 0(n 2 ), entre los cuales se incluyen los de burbujeo, de inserción, de selección y el denominado shellsort, y, por otro lado están los de complejidad 0(n * log(n)), entre los cuales se incluyen los algoritmos heapsort, mergesort y quicksort, De más está decir que los algoritmos pertenecientes al segundo grupo son en general más veloces que los pertenecientes al primero. Más allá de su complejidad algorítmica, la eficiencia de los distintos algoritmos de ordenamiento puede compararse utilizando datos empíricos, dado que la velocidad de u proceso de ordenamiento varía enormemente según las características del conjunto de datos a ordena, para obtener resultados empíricos precisos se debe realizar un gran número de ejecuciones de cada algoritmo sobre conjuntos de datos aleatorios, y luego, promediar los tiempos de ejecución para obtener una idea fiel del rendimiento. Por otro lado no todos los algoritmos se comportan igual ante conjuntos de datos con características particulares. Por ejemplo, si se requiere un algoritmo para mantener el orden en una lista casi ordenada es decir, una lista en la que relativamente pocos elementos se encuentran desordenados-, el algoritmo de burbujeo pude estar entre los mas eficientes, aunque es más complejo. Distinta es la situación cuando la lista a ordenar aparece con la mayoría de sus elementos desordenados. A su vez, el orden de complejidad de los algoritmos no refleja su eficiencia a la hora de ordenar conjuntos de pocos elementos. Por eso es que el orden de complejidad de un algoritmo refleja su eficiencia en un sentido asintótico. Página 22 de 33
23 Apéndice Apéndice 1 - Código fuente del Trabajo Práctico #include "stdio.h" #include "conio.h" #include "time.h" #include "stdlib.h" #include "iostream.h" #include "fstream.h" #include "string.h" #define elements //Algoritmos de ordenamiento implementados void bubblesort(int *, int); void heapsort(int *, int); void siftdown(int *, int, int ); void mergesort(int *, int *, int ); void m_sort(int *, int *, int, int ); void merge(int *, int *, int, int, int ); void selectionsort(int *, int); void shellsort(int *, int); void insertionsort(int *, int); void quicksort(int *, int); void q_sort(int *, int, int); //Funciones adicionales desarrolladas void gennumbers (int *, int); void gennumbersinv (int *, int); void gennumberssor (int *, int); void cpynumbers (int *, int *, int); void printnumbers (int *, int); int main(int argc, char* argv[]) int numbers[elements], aux_numbers[elements], corrida=1, maxcorrida; int temp[elements], option_algorithm; int option, actual_element=1, step=50; char fileref[5],filename[9]; clock_t tbubble1, tbubble2, theap1, theap2, tinsertion1, tinsertion2; clock_t tmerge1, tmerge2, tquick1, tquick2, tselection1, tselection2; clock_t tshell1, tshell2; cout << "Demo - Sorting algorithms" << endl; cout << "Number of elements: "<< elements << endl; cout << "Step 1 - Select the sort algorithms to run" << endl; cout << " 1) Bubble sort" << endl; cout << " 2) Heap sort" << endl; cout << " 3) Insertion sort" << endl; cout << " 4) Merge sort" << endl; Página 23 de 33
24 cout << " 5) Quick sort" << endl; cout << " 6) Selection sort" << endl; cout << " 7) Shell sort" << endl; cout << " 8) Bubble, Insertion and Selection sort" <<endl; cout << " 9) Heap, Merge, Quick and Sbell sort" << endl; cout << " 10) All the sort algothims" << endl; cout << " your option?: "; cin >> option_algorithm; cout << "Step 2 - Select vector generator" << endl; cout << " 1) Random" << endl; cout << " 2) Sorted" << endl; cout << " 3) Worst" << endl; cout << " your option?: "; cin >> option; cout << "Step 3 - Select the number of times to execute" << endl; cout << " your option?: "; cin >> maxcorrida; cout << "Step 4 - Procesing" << endl; while (corrida <= maxcorrida) itoa(corrida,fileref,10); strcpy (filename,""); strcpy(filename,"sort"); strcat(filename,fileref); strcat(filename,".csv"); ofstream SortFile(filename, ios::out); cout << "Step Writing file " << filename << endl; SortFile << "Elementos, Bubble, Heap, Merge, Selection, Quick, Shell, Insertion" << endl; while (actual_element <= elements) switch (option) case 1: gennumbers (numbers,actual_element); break; case 2: gennumberssor (numbers,actual_element); break; case 3: gennumbersinv (numbers,actual_element); break; default: cout << "Option not valid"; return 1; ; tbubble1 = tbubble2 = clock(); if ((option_algorithm == 1) (option_algorithm == 8) (option_algorithm == 10) ) Página 24 de 33
25 cpynumbers(numbers,aux_numbers,actual_element); tbubble1= clock(); bubblesort (aux_numbers,actual_element); tbubble2 = clock(); SortFile << actual_element << "," << (tbubble2-tbubble1); theap1 = theap2 = clock(); if ((option_algorithm == 2) (option_algorithm == 9) (option_algorithm == 10)) cpynumbers(numbers,aux_numbers,actual_element); theap1= clock(); heapsort (aux_numbers,actual_element); theap2 = clock(); SortFile << "," << (theap2-theap1); tmerge1 = tmerge2 = clock(); if ((option_algorithm == 4) (option_algorithm == 9) (option_algorithm == 10) ) cpynumbers(numbers,aux_numbers,actual_element); tmerge1= clock(); mergesort (aux_numbers,temp,actual_element); tmerge2 =clock(); SortFile << "," << (tmerge2-tmerge1); tselection1 = tselection2= clock(); if ((option_algorithm == 6) (option_algorithm == 8) (option_algorithm == 10)) cpynumbers(numbers,aux_numbers,actual_element); tselection1= clock(); selectionsort (aux_numbers,actual_element); tselection2 = clock(); SortFile << "," << (tselection2-tselection1); tquick1 = tquick2 = clock(); if ((option_algorithm == 5) (option_algorithm == 9) (option_algorithm == 10)) cpynumbers(numbers,aux_numbers,actual_element); tquick1= clock(); quicksort (aux_numbers,actual_element); tquick2 = clock(); SortFile << "," << (tquick2-tquick1); Página 25 de 33
26 tshell1 = tshell2 = clock(); if ((option_algorithm == 7) (option_algorithm == 9) (option_algorithm == 10)) cpynumbers(numbers,aux_numbers,actual_element); tshell1= clock(); shellsort (aux_numbers,actual_element); tshell2 = clock(); SortFile << "," << (tshell2-tshell1); tinsertion1 = tinsertion2 = clock(); if ((option_algorithm == 3) (option_algorithm == 8) (option_algorithm == 10)) cpynumbers(numbers,aux_numbers,actual_element); tinsertion1= clock(); insertionsort (aux_numbers,actual_element); tinsertion2 = clock(); SortFile << "," << (tinsertion2-tinsertion1) << endl; actual_element += step; SortFile.close(); actual_element=1; corrida ++; cout << "Step 5 - Process completed" << endl; return 0; void cpynumbers (int numbers[], int aux_numbers[], int array_size) // Esta funcion copia los numeros de un vector pasado como parametro a otro. // Se esta usando para que los datos a ordenar sean los mismos evaluando // los distintos algoritmos. int i; for (i = 0; i <= (array_size - 1); i++) aux_numbers[i]=numbers[i]; void gennumbersinv (int * numbers, int array_size) // Esta funcion genera un vector con numeros completamente desordenados int i; for (i = 0; i <= (array_size - 1); i++) Página 26 de 33
27 numbers[i]=array_size -i; void gennumberssor (int * numbers, int array_size) // Esta funcion genera un vector con numeros completamente ordenados int i; for (i = 0; i <= (array_size - 1); i++) numbers[i]=i; void printnumbers (int numbers[], int array_size) int i, j, temp; for (i = 0; i <= (array_size - 1); i++) cout << numbers[i] << " "; cout << endl; void gennumbers (int numbers[], int array_size) int i, j, temp; for (i = 0; i <= (array_size - 1); i++) numbers[i]=rand()%100; void bubblesort(int numbers[], int array_size) int i, j, temp; for (i = (array_size - 1); i >= 0; i--) for (j = 1; j <= i; j++) if (numbers[j-1] > numbers[j]) temp = numbers[j-1]; numbers[j-1] = numbers[j]; numbers[j] = temp; Página 27 de 33
28 void heapsort(int numbers[], int array_size) int i, temp; for (i = (array_size / 2)-1; i >= 0; i--) siftdown(numbers, i, array_size); for (i = array_size-1; i >= 1; i--) temp = numbers[0]; numbers[0] = numbers[i]; numbers[i] = temp; siftdown(numbers, 0, i-1); void siftdown(int numbers[], int root, int bottom) int done, maxchild, temp; done = 0; while ((root*2 <= bottom) && (!done)) if (root*2 == bottom) maxchild = root * 2; else if (numbers[root * 2] > numbers[root * 2 + 1]) maxchild = root * 2; else maxchild = root * 2 + 1; if (numbers[root] < numbers[maxchild]) temp = numbers[root]; numbers[root] = numbers[maxchild]; numbers[maxchild] = temp; root = maxchild; else done = 1; void mergesort(int numbers[], int temp[], int array_size) m_sort(numbers, temp, 0, array_size - 1); Página 28 de 33
29 void m_sort(int numbers[], int temp[], int left, int right) int mid; if (right > left) mid = (right + left) / 2; m_sort(numbers, temp, left, mid); m_sort(numbers, temp, mid+1, right); merge(numbers, temp, left, mid+1, right); void merge(int numbers[], int temp[], int left, int mid, int right) int i, left_end, num_elements, tmp_pos; left_end = mid - 1; tmp_pos = left; num_elements = right - left + 1; while ((left <= left_end) && (mid <= right)) if (numbers[left] <= numbers[mid]) temp[tmp_pos] = numbers[left]; tmp_pos = tmp_pos + 1; left = left +1; else temp[tmp_pos] = numbers[mid]; tmp_pos = tmp_pos + 1; mid = mid + 1; while (left <= left_end) temp[tmp_pos] = numbers[left]; left = left + 1; tmp_pos = tmp_pos + 1; while (mid <= right) temp[tmp_pos] = numbers[mid]; mid = mid + 1; Página 29 de 33
30 tmp_pos = tmp_pos + 1; for (i=0; i <= num_elements; i++) numbers[right] = temp[right]; right = right - 1; void selectionsort(int numbers[], int array_size) int i, j; int min, temp; for (i = 0; i < array_size-1; i++) min = i; for (j = i+1; j < array_size; j++) if (numbers[j] < numbers[min]) min = j; temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; void shellsort(int numbers[], int array_size) int i, j, increment, temp; increment = 3; while (increment > 0) for (i=0; i < array_size; i++) j = i; temp = numbers[i]; while ((j >= increment) && (numbers[j-increment] > temp)) numbers[j] = numbers[j - increment]; j = j - increment; numbers[j] = temp; if (increment/2!= 0) increment = increment/2; else if (increment == 1) increment = 0; Página 30 de 33
31 else increment = 1; void insertionsort(int numbers[], int array_size) int i, j, index; for (i=1; i < array_size; i++) index = numbers[i]; j = i; while ((j > 0) && (numbers[j-1] > index)) numbers[j] = numbers[j-1]; j = j - 1; numbers[j] = index; void quicksort(int numbers[], int array_size) q_sort(numbers, 0, array_size - 1); void q_sort(int numbers[], int left, int right) int pivot, l_hold, r_hold; l_hold = left; r_hold = right; pivot = numbers[left]; while (left < right) while ((numbers[right] >= pivot) && (left < right)) right--; if (left!= right) numbers[left] = numbers[right]; left++; while ((numbers[left] <= pivot) && (left < right)) left++; if (left!= right) numbers[right] = numbers[left]; right--; Página 31 de 33
32 numbers[left] = pivot; pivot = left; left = l_hold; right = r_hold; if (left < pivot) q_sort(numbers, left, pivot-1); if (right > pivot) q_sort(numbers, pivot+1, right); Apendice 2 - Análisis de Algoritmos Analizar un algoritmo significa determinar la cantidad de recursos necesarios para ejecutarlo (como por ejemplo, tiempo y almacenamiento). La mayoría de los algoritmos están diseñados para trabajar con datos de entrada de longitud arbitraria. Usualmente, la eficiencia o complejidad de un algoritmo se establece como una función que relaciona el tamaño del conjunto de datos de entrada con la cantidad de pasos o unidades de almacenamiento requeridos para ejecutar el algoritmo. La mejor técnica para diferenciar la eficiencia de los algoritmos es el estudio de los órdenes de complejidad. El orden de complejidad se expresa generalmente en término de la cantidad de datos a procesar por el programa, cantidad que denominamos N. La cantidad de tiempo de procesamiento de un algoritmo por lo general está en función de N, y puede expresarse según los casos típicos (promedio) de ese N, o bien según casos extremos no deseables (peor caso). En el análisis teórico de los algoritmos, es común estimar su complejidad en sentido asintótico, es decir considerar valores de N tan grandes que la formula de la complejidad del algoritmo queda reducida a sólo sus miembros más relevantes. Esto es lo que hacen notaciones como la Big-O Notación Big-O La notación Big-O se utiliza para expresar la complejidad de un código. En un problema de tamaño N (por ejemplo N ítems a ordenar): Un método constante en el tiempo es de "orden 1": O(1) Un método que varía linealmente en el tiempo es de "orden N": O(N) Un método que varia cuadráticamente en el tiempo es de "orden N al cuadrado": O(N 2 ) Las expresiones Big-O no tienen constantes o términos de orden bajo. Esto se debe a que cuando N es muy grande, las constantes y los términos mas bajos no existen (un método constante será más rápido que uno lineal y este será más rápido que uno cuadrático). Definición formal: La función T(N) es O(F(N)) si existe una constante c y para valores de N mayores que un valor n 0 : T(N) <= c * F(N) Página 32 de 33
33 La idea es que T(N) es la exacta complejidad de un método o algoritmo como una función del problema de tamaño N, y F(N) es el limite superior de la complejidad (por ejemplo, el tiempo, espacio o lo que sea de un problema de tamaño N no será peor que F(N)). En la practica se busca el menor F(N). Por ejemplo, si consideramos T(N) = 3 * N Podemos ver que T(N) es O(N 2 ) eligiendo c = 4 y n 0 = 2. Esto es porque para todos los valores de N mayores que 2, se cumple que: 3 * N <= 4 * N 2 T(N) no es O(N), Sin importar los valores que se elijan para la constante c y el valor de n 0, Siempre se puede buscar un valor de N mayor que n 0 tal que 3 * N es mayor que c * N. Como Determinar las Complejidades Cómo determinar el tiempo de ejecución de un código?, Depende del tipo de instrucciones utilizadas. 1. Secuencia de instrucciones 2. instrucción 1; 3. instrucción 2; instrucción k; (Nota: Este código es una secuencia de exactamente k instrucciones) El tiempo total es la suma de los tiempos de cada instrucción: Tiempo total = tiempo (instrucción 1) + tiempo (instrucción 2) tiempo (instrucción k) Si cada instrucción es "simple" (solo involucra operaciones básicas) entonces el tiempo de cada instrucción es constante y el tiempo total también es constante: O(1). En los siguientes ejemplos se asume que las instrucciones son simples, a menos que se exprese lo contrario. 2. Instrucciones condicionales (if-then-else) 7. if (condición) 8. secuencia de instrucciones else 11. secuencia de instrucciones Aquí, se ejecutara la secuencia 1 o la secuencia 2. Entonces, el peor caso es el mas lento de los dos: max(tiempo(secuencia 1), tiempo(secuencia 2)). Por ejemplo, si la secuencia 1 es O(N) y la secuencia 2 es O(1) el peor caso para todo el código condicional debe ser O(N). 3. Ciclos Página 33 de 33
34 14. for (i = 0; i < N; i++) 15. secuencia de instrucciones 16. El ciclo se ejecuta N veces, entonces la secuencia de instrucciones también se ejecuta N veces. Como asumimos que las instrucciones son O(1), El tiempo total para el ciclo es N * O(1), lo cual seria O(N). 4. Ciclos anidados 18. for (i = 0; i < N; i++) 19. for (j = 0; j < M; j++) 20. secuencia de instrucciones El ciclo exterior se ejecuta N veces. Por cada una de esas ejecuciones, el ciclo interno se ejecuta M veces. Como resultado, las instrucciones en el ciclo interno se ejecutan un total de N * M veces. En este caso, la complejidad es de O(N * M). En el común de los casos, donde la condición de fin del ciclo interior es que j < N, igual al ciclo exterior, la complejidad total para los dos ciclos es de O(N 2 ). Página 34 de 33
35 Apendice 3 - Referencias Página 35 de 33
Algoritmos de Ordenamiento
Algoritmos de Ordenamiento Fernando A. Lagos B. Copyleft 2007 INDICE 1 Introducción Pág. 3 2 Tipos de Algoritmos Pág. 4 2.1 Algoritmos iterativos Pág. 5 2.2 Algoritmos recursivos Pág. 6 3 Método de la
Notación Asintótica 2
Notación Asintótica 2 mat-151 1 Éxamen Rápido (6 minutos) Cada operación fundamental usa c milisegundos, cuánto tiempo toma contar hasta 1,000,000? Cuál es el valor de N? Cuál es el órden de complejidad
<tipo> Tipo de dato de los elementos del vector
Vectores y matrices Declaración Vector (array unidimiensional): []; Tipo de dato de los elementos del vector Identificador de la variable.
La eficiencia de los programas
La eficiencia de los programas Jordi Linares Pellicer EPSA-DSIC Índice General 1 Introducción... 2 2 El coste temporal y espacial de los programas... 2 2.1 El coste temporal medido en función de tiempos
NOTACIÓN O GRANDE. El análisis de algoritmos estima el consumo de recursos de un algoritmo.
NOTACIÓN O GRANDE El análisis de algoritmos estima el consumo de recursos de un algoritmo. Esto nos permite comparar los costos relativos de dos o más algoritmos para resolver el mismo problema. El análisis
Sorting++ Herman Schinca. Clase 21. 10 de Junio de 2011
Sorting++ Herman Schinca Clase 21 10 de Junio de 2011 Recordando Ya vimos 3 algoritmos de ordenamiento basados en la comparación entre elementos: Selection, Insertion y Bubble. Los 3 en peor caso (cuando
Estructuras de control
Estructuras de control Introducción Los algoritmos vistos hasta el momento han consistido en simples secuencias de instrucciones; sin embargo, existen tareas más complejas que no pueden ser resueltas empleando
Guía práctica de estudio 05: Diagramas de flujo
Guía práctica de estudio 05: Diagramas de flujo Elaborado por: M.C. Edgar E. García Cano Ing. Jorge A. Solano Gálvez Revisado por: Ing. Laura Sandoval Montaño Guía práctica de estudio 05: Diagramas de
Tema: Métodos de Ordenamiento. Parte 1.
Programación IV. Guía 2. 1 Facultad: Ingeniería Escuela: Computación Asignatura: Programación IV Tema: Métodos de Ordenamiento. Parte 1. Objetivos Específicos Identificar la estructura de algunos algoritmos
Fundamentos de programación
Fundamentos de programación Estructuras de Control Estructuras de control Estructuras de control Estructura secuencial Estructura alternativa Sentencias if, if else Sentencias if else anidadas El operador
Estatutos de Control C# Estatutos de Decisión (Selección)
SELECCIÓN Estatutos de Control C# Estatutos de Decisión (Selección) IF Condición THEN Estatuto1 ELSE Estatuto2 Estatuto1 Statement Condición... Antes de ver esta presentación: Lee el Capítulo correspondiente
Estructuras de Control
Algorítmica y Lenguajes de Programación Estructuras de Control Estructuras de Control. Introducción Hasta ahora algoritmos han consistido en simples secuencias de instrucciones Existen tareas más complejas
Instrucciones de control
Instrucciones de control Instrucciones de control de flujo C# ofrece un conjunto de sentencias similar al de C, C++ o Java. A continuación se estudian muy brevemente cada una de ellas. if if se utiliza
TEMA 7: Ficheros. TEMA 7: Ficheros. 7.1.-Concepto de fichero
TEMA 7: Ficheros 7.1.-Concepto de fichero Todas las estructuras de datos que hemos visto hasta ahora utilizan memoria principal. Esto tiene dos limitaciones importantes: 1. Los datos desaparecen cuando
Agradecimientos. Nota de los autores. 1 Problemas, algoritmos y programas 1
Prologo Agradecimientos Nota de los autores Índice general I III V VII 1 Problemas, algoritmos y programas 1 1.1 Programas y la actividad de la programación.................... 4 1.2 Lenguajes y modelos
Complejidad de Algoritmos
Complejidad de Algoritmos Tema 5 Introducción Un algoritmo es una secuencia de instrucciones que resuelve un problema Puede tener diferentes implementaciones Para comparar las diferentes formas (algoritmos)
Inecuaciones lineales y cuadráticas
Inecuaciones lineales y cuadráticas 0.1. Inecuaciones lineales Una inecuación lineal tiene la forma ax + b < 0 ó ax + b > 0 ó ax + b 0 ó ax + b 0. El objetivo consiste en hallar el conjunto solución de
Programación. Tema 8: Tablas Hash. Apuntes elaborados por: Eduardo Quevedo, Aaron Asencio y Raquel López Revisado por: Javier Miranda el????
Programación. Tema : Tablas Hash /Mayo/ Apuntes elaborados por: Eduardo Quevedo, Aaron Asencio y Raquel López Revisado por: Javier Miranda el???? Tema : Tabla Hash Las tabla hash aparece para conseguir
Introducción a las sentencias de control
INSTRUCCIONES DE CONTROL CONTENIDOS 1. Introducción a las sentencias de control. 2. Instrucciones o sentencias condicionales: IF, IF-ELSE, SWITCH. 3. Instrucciones o sentencias repetitivas o iterativas:
Ejemplo, generación de #s aleatorios
Ejemplo, generación de #s aleatorios Supón que tienes un generador de números aleatorios enteros [0,2] con distribución uniforme, y tu necesitas generar números con distribución uniforme [0,4]. Alguien
Problemas de Recursividad
Problemas de Recursividad Problema 1. El factorial de un número entero n 0, denotado como n!, se define! como!!! i = 1 2 n cuando n > 0, y 0! = 1. Por ejemplo 6! = 1 2 3 4 5 6 = 720 Diseñad una método
Control de Flujo. Estructuras de Control! Experiencia Educativa de Algorítmica CONTROL DE FLUJO
Control de Flujo Estructuras de Control Experiencia Educativa de Algorítmica 1 Introducción El estilo de como escribimos y analizamos un algoritmo se convierte en una de las principales características
Práctica 4 El algoritmo QuickSort, comparación de algoritmos de ordenación
Práctica 4 El algoritmo QuickSort, comparación de algoritmos de ordenación Estructuras de datos y algoritmos Facultad de Informática curso 2008-2009 Introducción El objetivo de esta práctica consiste en
Introducción a C++ y Code::Blocks
Introducción a C++ y Práctica Imperativo Clase 1 Luis Agustín Nieto Departamento de Computación, FCEyN,Universidad de Buenos Aires. 28 de mayo de 2010 Menu de esta Tarde Funcional Vs. Imperativo (Intérprete
INSTITUTO DE FORMACIÓN DOCENTE DE CANELONES DIVISIBILIDAD
DIVISIBILIDAD Definición de múltiplo Dados los números naturales a y b, se dice que a es múltiplo de b, si y solo si existe un número natural k, único, tal que a = b.k El número k se dice que es el cociente
Estructuras de Repetición (Repita para)
Estructuras de Repetición (Repita para) Andrés Arcia Departamento de Computación Escuela de Ingeniería de Sistemas Facultad de Ingeniería Universidad de Los Andes Programación Digital I 1 REPITA PARA Fijar
Métodos para escribir algoritmos: Diagramas de Flujo y pseudocódigo
TEMA 2: CONCEPTOS BÁSICOS DE ALGORÍTMICA 1. Definición de Algoritmo 1.1. Propiedades de los Algoritmos 2. Qué es un Programa? 2.1. Cómo se construye un Programa 3. Definición y uso de herramientas para
Elementos de un programa en C
Elementos de un programa en C Un programa en C consta de uno o más archivos. Un archivo es traducido en diferentes fases. La primera fase es el preprocesado, que realiza la inclusión de archivos y la sustitución
Estructuras en LabVIEW.
Estructuras en LabVIEW. Sumario: 1. Ejecución según el flujo de datos. 2. Estructuras básicas disponibles en LabVIEW. a) Estructura Sequence. b) Estructura Case. c) Estructura For Loop. d) Estructura While
e-mail: mtoledo@dgrfsa.gov.ar
Arreglos Introducción a las Estructuras de Datos. Arreglos Unidimensionales: Vectores Vectores Estáticos en VB Vectores Dinámicos en VB Ordenando un Vector Introducción a las Estructuras de Datos. Una
UNIVERSIDAD DE LOS ANDES NUCLEO UNIVERSITARIO RAFAEL RANGEL (NURR) DEPARTAMENTO DE FISICA Y MATEMATICA AREA COMPUTACION TRUJILLO EDO.
UNIVERSIDAD DE LOS ANDES NUCLEO UNIVERSITARIO RAFAEL RANGEL (NURR) DEPARTAMENTO DE FISICA Y MATEMATICA AREA COMPUTACION TRUJILLO EDO. TRUJILLO 1.- Resumen de Prog1 Comentarios es C++ Declaraciones de variables.
lasmatemáticas.eu Pedro Castro Ortega materiales de matemáticas
1. Fracciones Una fracción es una expresión del tipo a b, donde a y b son números naturales llamados numerador y denominador, respectivamente. 1.1. Interpretación de una fracción a) Fracción como parte
Cómo ordenar una lista de números?
Cómo ordenar una lista de números? Germán Ariel Torres Resumen. Este trabajo trata acerca de métodos y técnicas usadas para el ordenamiento eficiente de listas de números. Se analizan los métodos básicos,
GLOSARIO DE MICROSOFT VISUAL BASIC (HAZ CLIC EN LA OPCION DEL MENU Y ACCEDERAS RAPIDAMENTE)
GLOSARIO DE MICROSOFT VISUAL BASIC (HAZ CLIC EN LA OPCION DEL MENU Y ACCEDERAS RAPIDAMENTE) Menú 1. Operadores Matemáticos 2. Operadores relacionales 3. Funciones de Visual Basic 4. Tipos de variables
Programación Estructurada
Programación Estructurada PROGRAMACIÓN ESTRUCTURADA 1 Sesión No. 2 Nombre: El lenguaje de programación C Contextualización Una constante en todos los lenguajes de programación (viejos y nuevos) es la implementación
Algoritmos de Búsqueda y Ordenamiento
Departamento de Informática Universidad Técnica Federico Santa María Algoritmos de Búsqueda y Ordenamiento Programación de Computadores IWI--p Prof.: Teddy Alfaro Olave Algoritmos de Búsqueda Los procesos
Funciones. Parámetros por valor
Funciones I Parámetros por valor Fundamentos de Programación Fundamentos de Programación I Llamada a la función definición subprograma Subprogramas en C++ Funciones 1 Una función es un subprograma que
Análisis asintótico: algoritmos recursivos e iterativos
Análisis asintótico: algoritmos recursivos e iterativos Frank Sebastián Franco Hernández 22 de agosto de 2014 1. Análisis de tres algoritmos de ordenamiento 1.1. Algoritmo BubbleSort Este algoritmo funciona
Analisis de algoritmos
Analisis de algoritmos Eficiencia Es la capacidad de disponer de un recurso. En el caso de los algoritmos, la eficiencia se logra haciendo el mejor uso posible de los recursos del sistema. Recursos Qué
Programación de Sistemas
Programación de Sistemas Algoritmos de Ordenación Índice Por qué es importante la ordenación? Un par de ejemplos InsertionSort QuickSort Para cada uno veremos: En qué consisten, Casos extremos Eficiencia
Tema 2 Introducción a la Programación en C.
Tema 2 Introducción a la Programación en C. Contenidos 1. Conceptos Básicos 1.1 Definiciones. 1.2 El Proceso de Desarrollo de Software. 2. Lenguajes de Programación. 2.1 Definición y Tipos de Lenguajes
Definición de Memoria
Arquitectura de Ordenadores Representación de Datos en Memoria Abelardo Pardo abel@it.uc3m.es Universidad Carlos III de Madrid Departamento de Ingeniería Telemática Definición de Memoria DRM-1 La memoria
Fundamentos de Programación Visual Basic
Pág. N. 1 Fundamentos de Programación Visual Basic Familia: Editorial: Tecnología de información y computación Macro Autor: Ricardo Walter Marcelo Villalobos ISBN: 978-612-304-236-3 N. de páginas: 280
Problema - Sumando Digitos
Primera Olimpiada de Informática Problema - Sumando Digitos Comenzando con un entero entre 00 y 99 inclusive, escritos como dos dígitos (use un cero a la izquierda en caso de que el numero sea menor que
Todo programa en 'C' consta de una o más funciones, una de las cuales se llama main.
LENGUAJE C CARACTERISTICAS DEL LENGUAJE 'C' El lenguaje 'C' se conoce como un lenguaje compilado. Existen dos tipos de lenguaje: interpretados y compilados. Los interpretados son aquellos que necesitan
Sistemas Operativos Practica 1: procesos y concurrencia.
Sistemas Operativos Practica 1: procesos y concurrencia. Objetivos: Introducir al alumno a los conceptos de programa, concurrencia, paralelismo y proceso o tarea. Manejo del concepto de concurrencia haciendo
OPTIMIZACIÓN VECTORIAL
OPTIMIZACIÓN VECTORIAL Métodos de Búsqueda Directa Utilizan sólo valores de la función Métodos del Gradiente Métodos de Segundo Orden Requieren valores aproimados de la primera derivada de f) Además de
MEDIDAS DE TENDENCIA CENTRAL
MEDIDAS DE TENDENCIA CENTRAL Al describir grupos de observaciones, con frecuencia es conveniente resumir la información con un solo número. Este número que, para tal fin, suele situarse hacia el centro
Algoritmos. Medios de expresión de un algoritmo. Diagrama de flujo
Algoritmos En general, no hay una definición formal de algoritmo. Muchos autores los señalan como listas de instrucciones para resolver un problema abstracto, es decir, que un número finito de pasos convierten
Desde los programas más simples escritos en un lenguaje de programación suelen realizar tres tareas en forma secuencial.
Tipos de Datos Desde los programas más simples escritos en un lenguaje de programación suelen realizar tres tareas en forma secuencial. Entrada de datos Procesamientos de datos Salida de resultados Los
Apuntadores (Punteros)
Apuntadores (Punteros) x9ff10 X int 209 SESION 7 *ptr Definición Llamados también punteros. Un Apuntador es una variable que contiene una dirección de memoria, la cual corresponderá a un dato o a una variable
Aritmética de Enteros
Aritmética de Enteros La aritmética de los computadores difiere de la aritmética usada por nosotros. La diferencia más importante es que los computadores realizan operaciones con números cuya precisión
Representación de números enteros: el convenio exceso Z
Representación de números enteros: el convenio exceso Z Apellidos, nombre Martí Campoy, Antonio (amarti@disca.upv.es) Departamento Centro Informàtica de Sistemes i Computadors Escola Tècnica Superior d
Programación de Computadores 4 Iteraciones y Decisiones. Prof. Javier Cañas. Universidad Técnica Federico Santa María Departamento de Informática
Programación de Computadores 4 Iteraciones y Decisiones Prof. Javier Cañas Universidad Técnica Federico Santa María Departamento de Informática Contenido 1 Introducción 2 Operadores Relacionales y Lógicos
Unidad Didáctica 2. Elementos básicos del lenguaje Java Tipos, declaraciones, expresiones y asignaciones
Unidad Didáctica 2 Elementos básicos del lenguaje Java Tipos, declaraciones, expresiones y asignaciones Fundamentos de Programación Departamento de Lenguajes y Sistemas Informáticos Versión 1.0.3 Índice
Algebra lineal y conjuntos convexos
Apéndice A Algebra lineal y conjuntos convexos El método simplex que se describirá en el Tema 2 es de naturaleza algebraica y consiste en calcular soluciones de sistemas de ecuaciones lineales y determinar
Funciones como Subprogramas en C++
FUNCIONES Cuando es necesario escribir programas complicados para resolver problemas complejos, una práctica común entre los programadores es descomponer el algoritmo (el diagrama de flujo) en varias partes.
Práctica 3. Paso de parámetros entre subrutinas. 3. Consideraciones sobre el paso de parámetros
Práctica 3. Paso de parámetros entre subrutinas 1. Objetivo de la práctica El objetivo de esta práctica es que el estudiante se familiarice con la programación en ensamblador y el convenio de paso de parámetros
Tema 8: Algoritmos de ordenación y búsqueda
Tema 8: Algoritmos de ordenación y búsqueda Objetivos: en este tema se presentan algoritmos que permiten buscar un elemento dentro de una colección y ordenar una colección en base a algún criterio (el
UNIDAD III NÚMEROS FRACCIONARIOS
UNIDAD III NÚMEROS FRACCIONARIOS COMPETENCIAS E INDICADORES DE DESEMPEÑO Identifica los números fraccionarios y realiza operaciones con ellos. Identifica los porcentajes, decimales y fraccionarios y realiza
Programcaión Básica. Secuencias de Control y Repetición. Arturo Vega González.
Programación Básica Arturo Vega González a.vega@ugto.mx Division de Ciencias e Ingenierías Universidad de Guanajuato Campus León Sesión 5 Universidad de Guanajuato, DCI, Campus León 1 / 31 Universidad
la solución a una ecuación cuadrática solicitando al usuario los términos de dicha ecuación.
ALGORITMOS SECUENCIALES: La estructura secuencial es aquella en la que una acción (instrucción) sigue a otra en secuencia. Las tareas se suceden de tal modo que la salida de una es la entrada de la siguiente
Tema 14: Sistemas Secuenciales
Tema 14: Sistemas Secuenciales Objetivos: (CONTADORES) Introducción. Características de los contadores. Contadores Asíncronos. Contadores Síncronos. 1 INTRODUCCIÓN Los contadores son sistemas secuenciales
ANEXO 1. CONCEPTOS BÁSICOS. Este anexo contiene información que complementa el entendimiento de la tesis presentada.
ANEXO 1. CONCEPTOS BÁSICOS Este anexo contiene información que complementa el entendimiento de la tesis presentada. Aquí se exponen técnicas de cálculo que son utilizados en los procedimientos de los modelos
Tema 4. Operadores y Expresiones
Tema 4 Operadores y Expresiones Contenidos 1. Conceptos Básicos. 2. Operadores Aritméticos. 3. Operadores de Relación, de Igualdad y Lógicos. 4. Operadores de Incremento y Decremento. 5. Operadores y Expresiones
TEMA 4. ESTRUCTURAS DE CONTROL
M.P. Sesmero, P. de Toledo, F.J. Ordoñez, J. Gómez-Romero, J.A. Iglesias, J.L. Mira Programación TEMA 4. ESTRUCTURAS DE CONTROL Grado en Ingeniería en Tecnologías Industriales Programación CONTENIDOS 4.1.
ALGORITMOS DE ORDENACIÓN Y BÚSQUEDA
6 ALGORITMOS DE ORDENACIÓN Y BÚSQUEDA OBJETIVOS Después del estudio de este capítulo usted podrá: Conocer los algoritmos basados en el intercambio de elementos. Conocer el algoritmo de ordenación por inserción.
Java para programadores
Java para programadores Java y Servicios Web I Master en Ingeniería Matemática Manuel Montenegro Dpto. Sistemas Informáticos y Computación Desp. 467 (Mat) montenegro@fdi.ucm.es Contenidos Variables. Tipos
CAPÍTULO 4 TÉCNICA PERT
54 CAPÍTULO 4 TÉCNICA PERT Como ya se mencionó en capítulos anteriores, la técnica CPM considera las duraciones de las actividades como determinísticas, esto es, hay el supuesto de que se realizarán con
Universidad de Pamplona Materia: Programación 1 Docente: Ing. Lusbin Raúl Vargas LENGUAJE C ESTRUCTURA DE UN PROGRAMA EN C
Universidad de Pamplona Materia: Programación 1 Docente: Ing. Lusbin Raúl Vargas LENGUAJE C ESTRUCTURA DE UN PROGRAMA EN C Directivas del procesador Main() { Declaraciones Definiciones proposiciones }
Medidas de centralización
1 1. Medidas de centralización Medidas de centralización Hemos visto cómo el estudio del conjunto de los datos mediante la estadística permite realizar representaciones gráficas, que informan sobre ese
5. Sentencias selectivas o condicionales
60 A. García-Beltrán y J.M. Arranz 5. Sentencias selectivas o condicionales Objetivos: a) Describir el funcionamiento de las sentencias selectivas o condicionales (if-else y switch) b) Interpretar el resultado
1 Estructura básica de un programa C++
Elementos básicos de un lenguaje de alto nivel: C++ CONTENIDOS 1. Estructura básica de un programa C++. 2. Tipos de datos simples. 3. Constantes y variables en C++. Declaración. 4. Operadores y expresiones.
Tema 2. El lenguaje JAVA
Tema 2. El lenguaje JAVA Nomenclatura habitual Variables Tipos de variables Tipos primitivos Referencias Arrays Operadores Operadores de Java Precedencia de operadores Sentencias de control Sentencias
ESTADÍSTICA DESCRIPTIVA
ESTADÍSTICA DESCRIPTIVA Medidas de tendencia central y de dispersión Giorgina Piani Zuleika Ferre 1. Tendencia Central Son un conjunto de medidas estadísticas que determinan un único valor que define el
Fundamentos de Programación. Flujo de Control I: Estructuras selectivas
Fundamentos de Programación Flujo de Control I: Estructuras selectivas El Flujo de Control de un Programa Un algoritmo puede ser construido utilizando combinaciones de tres estructuras de control de flujo
Procesadores de lenguaje Tema 6 La tabla de símbolos
Procesadores de lenguaje Tema 6 La tabla de símbolos Departamento de Ciencias de la Computación Universidad de Alcalá Resumen La tabla de símbolos. Requerimientos de información. Diseño de la tabla de
Ciclos. Recordando Estructuras de Control Básicas: SELECCIÓN (condición) SECUENCIAL
Ciclos Fundamentos de Programación Recordando Estructuras de Control Básicas: Una secuencia es una serie de estatutos que se ejecutan uno después de otro. Selección (condición) ejecuta diferentes estatutos
Relación de prácticas de la asignatura METODOLOGÍA DE LA PROGRAMACIÓN Segundo Cuatrimestre Curso º Grado en Informática
Relación de prácticas de la asignatura METODOLOGÍA DE LA PROGRAMACIÓN Segundo Cuatrimestre Curso 2013-2014. 1º Grado en Informática Práctica 2: Memoria dinámica y Bibliotecas Objetivos Practicar conceptos
Instituto Tecnológico de Celaya
CADENAS DE CARACTERES Hasta ahora se han manejado variables de tipo caracter cuyo valor es un sólo caracter. En algunos casos, sin embargo, es necesario usar variables cuyos valores sean un conjunto (cadena)
Algoritmos y programas. Algoritmos y Estructuras de Datos I
Algoritmos y programas Algoritmos y Estructuras de Datos I Primer cuatrimestre de 2012 Departamento de Computación - FCEyN - UBA Programación funcional - clase 1 Funciones Simples - Recursión - Tipos de
Estadística Inferencial. Estadística Descriptiva
INTRODUCCIÓN Estadística: Ciencia que trata sobre la teoría y aplicación de métodos para coleccionar, representar, resumir y analizar datos, así como realizar inferencias a partir de ellos. Recogida y
ANEXO 1. CALIBRADO DE LOS SENSORES.
ANEXO 1. CALIBRADO DE LOS SENSORES. Las resistencias dependientes de la luz (LDR) varían su resistencia en función de la luz que reciben. Un incremento de la luz que reciben produce una disminución de
Lección 2: Notación exponencial
GUÍA DE MATEMÁTICAS III Lección 2: Notación exponencial En la lección anterior hemos visto cómo trabajar con números reales y cómo para facilitar el trabajo con ellos es conveniente utilizar aproximaciones,
Prof. Dr. Paul Bustamante
Prácticas de C++ Practica Nº 3 Informática II Fundamentos de Programación Prof. Dr. Paul Bustamante Practica Nº3 Programación en C++ Pág. 1 ÍNDICE ÍNDICE... 1 1. Introducción... 1 1.1 Ejercicio 1: Mi primeras
UNIVERSIDAD NACIONAL AUTÓNOMA DE MÉXICO. Introducción FACULTAD DE INGENIERÍA. Ordenación
Introducción Uno de los procedimientos más comunes y útiles en el procesamiento de datos, es la clasificación u ordenación de los mismos. Se considera ordenar al proceso de reorganizar un conjunto dado
LEVANTAMIENTO DE UN LOTE POR MEDIO DE UNA POLIGONAL
METODOS PARA MEDIR UN TERRENO CON TRANSITO Y CINTA POR MEDIO DE UNA POLIGONAL EN QUE CONSISTE?: En trazar un polígono que se ajuste aproximadamente a los linderos del terreno, en donde, desde los vértices
4. Operadores Operador asignación
Programación orientada a objetos con Java 43 4. Operadores Objetivos: a) Describir los operadores (aritméticos, incrementales, de relación, lógicos y de asignación) y los tipos de dato primitivos sobre
Un paquete de problemas de potenciación
Un paquete de problemas de potenciación Betina Zolkower- Adriana Rabino- Ana Bressan A continuación se presenta una serie de problemas de potenciación y distintas estrategias de resolución. Betina Zolkower
ESTRUCTURAS CONDICIONALES SIMPLES: ESTRUCTURAS CONDICIONALES DOBLES: ESTRUCTURAS CONDICIONALES ANIDADAS:
ESTRUCTURAS CONDICIONALES SIMPLES: Si (Condición) entonces if (Condición) { ESTRUCTURAS CONDICIONALES DOBLES: Si (Condición) entonces if (Condición) { { ESTRUCTURAS CONDICIONALES ANIDADAS: Si (Condición1)
Teorema Central del Límite (1)
Teorema Central del Límite (1) Definición. Cualquier cantidad calculada a partir de las observaciones de una muestra se llama estadístico. La distribución de los valores que puede tomar un estadístico
MATEMATICA GRADO 9 II PERIODO PROF. LIC. ESP. BLANCA NIEVES CASTILLO R. CORREO: cel
GUIA DE TEORIA NO. 1 LO QUE DEBO SABER Regla de Cramer Un sistema de ecuaciones lineales se dice de Cramer cuando cumple las siguientes condiciones: Es un sistema cuadrado, con igual número de ecuaciones
Estructuras de Repetición (Hacer-Mientras)
Estructuras de Repetición (Hacer-Mientras) Material Original: Prof. Flor Narciso Modificaciones: Prof. Andrés Arcia Departamento de Computación Escuela de Ingeniería de Sistemas Facultad de Ingeniería
Introducción al tipo Vector Cómo guardar una colección de datos conceptualmente relacionados? - almacenar los 100 primeros números primos, - al
Tema 6. Vectores 1. Introducción y Definiciones 2. Operaciones elementales con vectores 3. Definición y manejo de vectores (arrays arrays) en C 4. Operación de Recorrido secuencial de un vector 5. Operación
Continuación Números Naturales:
Continuación Números Naturales: Múltiplos y divisores de un número natural. Reglas de divisibilidad. Mínimo común múltiplo y Máximo común divisor. Ejercicios de aplicación. Continuación Números Naturales:
ESTADÍSTICA. Población Individuo Muestra Muestreo Valor Dato Variable Cualitativa ordinal nominal. continua
ESTADÍSTICA Población Individuo Muestra Muestreo Valor Dato Variable Cualitativa ordinal nominal Cuantitativa discreta continua DISTRIBUCIÓN DE FRECUENCIAS Frecuencia absoluta: fi Frecuencia relativa:
Revisora: María Molero
57 Capítulo 5: INECUACIONES. Matemáticas 4ºB ESO 1. INTERVALOS 1.1. Tipos de intervalos Intervalo abierto: I = (a, b) = {x a < x < b}. Intervalo cerrado: I = [a, b] = {x a x b}. Intervalo semiabierto por
UNIDAD ACADÉMICA PROFESIONAL TIANGUISTENCO
UNIDAD ACADÉMICA PROFESIONAL TIANGUISTENCO LICENCIATURA EN PRODUCCIÓN INDUSTRIAL. UNIDAD DE APRENDIZAJE: PROGRAMACIÓN Créditos institucionales de la UA: 6 Material visual: Diapositivas Unidad de competencia
TEMA 1.- POLINOMIOS Y FRACCIONES ALGEBRAICAS
TEMA 1.- POLINOMIOS Y FRACCIONES ALGEBRAICAS 1.- POLINOMIOS Recordemos que un monomio es una expresión algebraica (combinación de letras y números) en la que las únicas operaciones que aparecen entre las
Otra característica poblacional de interés es la varianza de la población, 2, y su raíz cuadrada, la desviación estándar de la población,. La varianza
CARACTERÍSTICAS DE LA POBLACIÓN. Una pregunta práctica en gran parte de la investigación de mercado tiene que ver con el tamaño de la muestra. La encuesta, en principio, no puede ser aplicada sin conocer