Estructura de Datos

Prctica 1: Anlisis de eficiencia de los algoritmos.

Francisco Jos Fernndez Muelas 2B, GII

Ejercicio1: Realizarelanlisisdeeficienciacuandoconsideramoselcdigoenocurrencias.cpp. Enestecaso,debemosdemodificarelcdigoparaasegurarnosquetenemos lamismasalidaqueenelejemplodelalgoritmoburbuja(tamaoytiempo). NOTA:Enelficheroseilustracmosepuederealizarlatomadetiempos cuandolaprecisindelrelojnoessuficiente. Analizamos tericamente el algoritmo: intcontar_hasta(vector<string>&V,intini,intfin,string& s){ intcuantos=0; for(inti=ini;i<fin;i++) if(V[i]==s){ cuantos++; } returncuantos; } Primero se analiza la eficiencia del bucle for. El cuerpo de este est formado por 2 setencias cuya eficiencia es de O(1), y el bucle da fin - ini iteraciones, por lo que su tiempo de ejecucin depender del tamao de las entrada, es decir, su eficiencia ser de O(n). El resto del cdigo del algoritmo esta formado por sentencias de ef. O(1), por lo que el orden de eficiencia total del algoritmo ser de n: O(n). Ahora se realiza el anlisis emprico: El primer paso es compilar el cdigo del programa y ejecutarlo, guardando las salidas en un archivo. Se escriben los siguientes comandos en una terminal: #g++ocurrencias.cppoocurrencias #./ocurrencias>ocurrencias.dat El archivo ocurrencias.dat contendr 2 columnas de datos, la primera con el tamao de las entradas y la segunda con el tiempo que requiere el algoritmo para ese tamao de entradas. Una vez obtenidos los tiempos de ejecucin, se analizan grficamente con el programa gnuplot. Para ello se ejecutan los siguientes comandos en una terminal: #gnuplot plotocurrencias.dat //Esto produce la siguiente salida:

Lo que confirma que la eficiencia del algoritmo es de O(n). Ahora buscamos la recta de regresin y la ajustamos a la salida grfica del algoritmo: f(x)=a*x fitf(x)ocurrencas.datviaa plotocurrencias.dat,f(x) Y se produce la siguiente salida:

Ejercicio2: Realizarelanlisisdeeficienciatericoyprcticoconlosalgoritmosdeordenacin queseconocen(burbuja,insercinyseleccin)considerandocomoentradasel ficherolema.txt.Unavezrealizadoelanlisisindividualrealizarunacomparacin conjuntadesueficiencia. Anlisis terico de los algoritmos:

Burbuja:
voidburbuja(vector<string>&T,intinicial,intfinal){ inti,j; stringaux; for(i=inicial;i<final1;i++)//Buclemayor. for(j=final1;j>i;j)//Bucleinterno. if(T[j]<T[j1]){ aux=T[j]; T[j]=T[j1]; T[j1]=aux; } Este algoritmo esta formado por sentencias de eficiencia de O(1) junto con una estructura de bucles for anidados. Dentro de la estructura de bucles: Bucle interno: El cuerpo de este bucle est formado por sentencias simples, de O(1), que se repiten un nmero de veces delimitado por el tamao de las entrada, n, por lo que la eficiencia es de O(n). Bucle mayor: Este bucle se realiza una serie de final-inicial veces, por lo tanto depende del tamao de las entradas (n) y su orden de eficiencia es (n_interaciones)*(cuerpo) = (n*n) O(n).

Seleccin:
voidseleccion(vector<string>&T,intinicial,intfinal){ intmin,j; stringaux; for(inti=inicial;i<final;i++){//Buclemayor. min=i; for(j=i+1;j<final;j++)//Bucleinterno. if(T[min]>T[j]) min=j; aux=T[min]; T[min]=T[i]; T[i]=aux; }

Para este algoritmo, el anlisis terico de eficiencia es prcticamente igual al del algoritmo de ordenacin por burbuja. Esta formado por sentencias de eficiencia de O(1) y por una estructura de bucles for anidada. Esta estructura est formada por: Bucle interno: Contiene sentencias simples de O(1) que se repiten un nmero de veces que vara en funcin del tamao de las entradas, por lo que la eficiencia de este bucle ser de O(n). Bucle mayor: Contiene el bucle interno y sentencias de O(1), que se repiten final-inicial veces, es decir, depende del tamao de las entradas. Por lo tanto, su orden de eficiencia ser de n*O(n) = O(n).

Insercin:
staticvoidinsercion(vector<string>&T,intinicial,intfinal){ stringaux; intj; for(inti=inicial;i<final1;i++){//Buclemayor. aux=T[i]; for(j=i1;j>=inicial&&T[j]>aux;j){//Buclemenor. T[j+1]=T[j]; T[j]=aux; } } } El algoritmo est formado por sentencias simples de orden de eficiencia constante, y de una estructura de bucles for anidados. Esta estructura contiene: Un bucle interno que se ejecuta un nmero determinado de veces, en el peor de los casos i veces, siendo i el iterador del bucle mayor. Por lo tanto, al eficiencia del bucle interno depende el tamao de la entrada que se le d a este, por lo que el bucle es de O(n). Un bucle mayor, cuyo cuerpo es de O(n), que se ejecuta final-inicial veces, por lo que su tiempo de ejecucin depender del tamao de las entradas que se le d. Esto implica un orden de eficiencia del bucle de n*n = O(n). Anlisis emprico de los algoritmos: Para empezar, hay que compilar cada archivo .cpp y ejecutarlo, introduciendo los datos de salida en un archivo de texto para cada uno de ellos. Esto se hace abriendo una terminal y ejecutando los siguientes comandos: #g++burbuja.cppoburbuja #g++insercion.cppoinsercion #g++seleccin.cpposeleccin #./burbuja>burbuja.dat& #./insercion>insercion.dat& #./seleccion>seleccin.dat&

Una vez obtenidos los archivos con los datos correspondientes, se ejecuta el programa gnuplot y se obtiene una representacin grfica de esos archivos, ejecutando para cada uno de ellos: plotNOMBREDEARCHIVO.dat Y obtenemos estas 3 salidas:

El siguiente paso es buscar la recta de regresin para cada algoritmo y ajustarla a su grfica. Para ello, ejecutamos los siguientes comandos para cada uno de los algoritmos: f(x)=a*x*x fitf(x)NOMBREDEARCHIVO.datviaa plotNOMBREDEARCHIVO.dat,f(x) Y obtenemos las siguientes salidas:

Por ltimo, hacemos una grfica comparativa de los tiempo de ejecucin de los tres algoritmos: plotinsercion.dat,seleccin.dat,burbuja.dat

Esto demuestra que el algoritmo mas ineficiente es de burbuja, seguido por muy poco por el de seleccin. El algoritmo de insercin es ms eficiente, aunque en este caso la diferencia es muy grande debido a que el archivo a ordenar, lema.txt ya est ordenado, por lo que el bucle interno del algoritmo de insercin solo tiene que dar siempre una iteracin por cada iteracin del bucle mayor. Para el archivo quijote.txt, los tiempos de ejecucin y la eficiencia de los algoritmos cambia, ya que este archivo no se encuentra ordenado. Aqu podemos ver la grfica comparativa de los 3 algoritmos para este nuevo archivo:

Se puede observar que ahora los tiempos de ejecucin del algoritmo de insercin est ms cercanos a los otros 2. An as, insercin sigue siendo el algoritmo mas eficiente de los 3. Ejercicio3: Realizarelanlisiscomparativodeeficienciaparalosalgoritmosdelfichero frecuencia.cpp.Enestecaso,nuestroobjetivoesvercmoelusodedistintas estructurasdedatosnospermitemejorarlaeficienciadenuestroalgoritmo.Eneste caso,seutilizandistintoscontenedoresdelaSTL. Enesteapartado,elobjetivodelapracticaespermitiralalumnoverlasventajas,en tiempodeejecucin,delusodeestructurasdedatosmsadecuadas,ynotantoel comprederelcmofuncionanlosdistintosalgoritmos. Para este ejercicio, hay que separar las distintas versiones del algoritmo contenidas en frecuencia.cpp y dividirlas en 4 archivos (v1.cpp, v2.cpp, v3.cpp y v4.cpp). Despues se compilan y se ejecutan *(), guardando los resultados en archivos de texto. Para comprobar la eficiencia de cada algoritmo, se obtienen las grficas con el programa gnuplot:

En esta ltima grfica, apenas se observan los resultados. Los tiempos de ejecucin en este ordenador son todos de 0 seg, excepto en algunos casos que sale 0.01, que estn marcados en la linea de arriba del grfico, por el ser el tamao mximo representado. *(): La ejecucin de la versin 3 del algoritmo produce un error de violacin del segmento, por lo que no he podido analizar su tiempo de ejecucin.