You are on page 1of 11

DESCRIPCIÓN GENERAL DEL PROBLEMA

La base del problema es realizar un análisis comparativo empírico de soluciones eficientes y
lineales, ambos de forma iterativa, para 3 problemas que se plantean, estos son:

 Calcular el k-ésimo elemento de una lista si ésta estuviera ordenada.

 Calcular ab.

 Buscar un valor dentro de un arreglo, si dichos elementos se hayan ordenados de mayor a
menor.

Se debe crear una única clase llamada Math2, a la cual tenemos que implementar los métodos
estáticos necesarios para resolver los problemas planteados.

Una vez terminada nuestra clase Math2 debemos crear una clase tipo Sistema que nos permita
crear conjuntos de datos de distinto tamaño, los cuales nos permitirán obtener los tiempos
resultantes para cada tipo de soluciones y así finalmente construir gráficos que nos muestren los
resultados obtenidos.

DESARROLLO
La Clase Math2:

Una vez comprendida nuestra descripción del problema, comenzamos a definir nuestra clase
Math2. Para solucionar el problema implementamos ocho funciones, estas son:

o La función BuscaKesimoIneficiente es la que encuentra el elemento k-ésimo,
ordenando el arreglo y entregando el elemento ingresado.

o La función BuscaKesimoEficiente es la que encuentra el elemento k-ésimo en el
cual usamos pivote y el método math.ceil para redondear, y construimos un ciclo
para identificarlo.

o La función PotenciaIneficiente es la que encuentra el valor de la expresión pero
con un tiempo de demora mayor, o sea ineficiente.

o La función PotenciaEficiente es la función que encuentra el valor de la expresión
de potencia de forma más rápida, o sea la más eficiente.

o La función BuscarIneficiente es la que busca en el arreglo el número pero se
demora, en conclusión es ineficiente.

return aux[k-1]. int pivote = (int)Math. int[] dosMayor=new int[tam-1]. Código: public class Math2{ public static int BuscaKesimoIneficiente(int []x. .inicio. int[] dosMenor=new int[tam-1].length-1. //creamos el ciclo para identificar el kaesimo while(true){ if (tam == 1) { return uno[0]. que se invoca en BuscarIneficiente. } //esto funciona solo con la mediana del arreglo// public static int BuscaKesimoEficiente(int [] x.int k){ int tam=x. int menores=0. i < tam.length. ósea es el más eficiente. quickSort(aux. y ordena los elementos del arreglo de menor a mayor. int[]aux. int[] uno=x. // creamos el pivote y usamos el metodo math. for (int i = 0.ceil(tam/2).z=0. } else { w=z=0.ceil para redondear. que se invocada en la función de BuscaKesimoIneficiente.int k){ int inicio = 0. int w=0. int tope = aux.  o La función BuscarEficiente es la que busca dentro de un arreglo un número y lo hace rápidamente.tope). y ordena los elementos del arreglo de mayor a menor.  o La función quickSort.  o La función quickSort2. aux = x. i++) { if (i != pivote) { if (uno[i] < uno[pivote]) { dosMenor[w] = uno[i].

ceil(tam/2). } else{ if(exponente == 1){ return base.i++){ mult = base * mult. z++. w++. for(int i=1. } else { uno=dosMayor. i++. } } } if (k == w + 1 + menores) { return uno[pivote]. } else { dosMayor[z] = uno[i]. if(exponente==0){ return 1. } return aux. } } .i<=Exponente. int Exponente) { int mult = 1. } return mult.int exponente){ int i = 0. } } pivote=(int)Math. } public static int PotenciaEficiente(int base. } else{ while(i<exponente-1){ aux = base*aux. int aux = base. } else { if (k <= w + menores) { uno=dosMenor. menores+=z+1. } } } public static int PotenciaIneficiente(int base. tam=w. tam=z.

i++) { if (x[i] == numero) { return true. if(i<=j){ int aux = a[i]. if (numero == x[pivote]) { return true.length . mayor = x.1. while(a[j]>pivot)j--.} public static boolean BuscarIneficiente(int x[] . int pivote.menor) / 2 + menor.1. } private static void quickSort( int a[]. int right){ int i = left. i++. if(i<right)quickSort(a.i. } else { if (numero > x[pivote]) { mayor = pivote . } } } return false.j). } } } return false. int numero) { for (int i = 0.length. int numero) { int menor = 0. int left. } else { if (numero > x[i]) { return false. } else { menor = pivote + 1. } public static boolean BuscarEficiente(int x[]. while (menor <= mayor) { pivote = (int) (mayor . if(left<j)quickSort(a. } }while(i<=j). int j = right. i < x.right). j--. a[j] = aux.left. a[i] = a[j]. int pivot = a[(int)(left+right)/2]. do{ while(a[i]<pivot)i++. } .

i++. usando la función PotenciaIneficiente de la clase Math2.i.right). Luego implementamos un pequeño menú en el cual podemos elegir probar e algoritmo entre 1000 elementos. usando la función BuscaEficiente de la clase Math2. Codigo Fuente: Código: . int pivot = a[(int)(left+right)/2]. usando la función BuscaKesimoIneficiente de la clase Math2. a[i] = a[j]. if(i<right)quickSort(a. usando la función BuscaIneficiente de la Clase Math2. y luego desplegar en pantalla los tiempos transcurridos para cada tipo de solución. do{ while(a[i]>pivot)i++. Para cada caso. y de manera ineficiente. para leer los datos que solicitará el programa al usuario. y desplegar en pantalla los tiempos transcurridos para cada tipo de solución. y eficiente. finalmente desplegamos en pantalla los tiempos para queda tipo de búsqueda. aquí ingresamos el número a buscar. donde debemos ingresar el valor de “K”. public static void quickSort2( int a[]. usando la función BuscaKesimoEficiente de la Clase Math2. int right){ int i = left. es decir.left. 10000 elementos. y lineal.j). j--. a[j] = aux. 100000 elementos. En seguida debemos ingresar el valor de ‘a’ (base) y el valor de ‘b’ (exponente). if(left<j)quickSort(a. haremos los siguientes pasos: Comenzaremos con encontrar el K-ésimo elemento del arreglo. usando la función PotenciaEficiente de la clase Math2. } } La Clase Usar: En primer lugar creamos el buffered. while(a[j]<pivot)j--. 10000 y 100000 elementos. encontrarlo dentro del arreglo de forma eficiente. int left. el valor de ‘a’ y ‘b’ para calcular ab y un valor a buscar dentro del arreglo. int j = right. if(i<=j){ int aux = a[i]. el valor de ‘k’ para calcular el k-ésimo. calcular el valor de la potencia de forma Ineficiente. probando nuestras soluciones con arreglos de 1000. } }while(i<=j). encontramos el elemento ingresado de manera eficiente. Luego se desea buscar un elemento dentro de un arreglo.

Random rand2 = new Random().f<x.length.println("Tiempo en nanosegundos de Busqueda del K-esimo Ineficiente es "+Time ). . int m = Integer.g++){ y[g] =rand3. int[]w = new int [1000].K). import java. Probar Algoritmos con 10000 elementos").out.nanoTime(). Probar Algoritmos con 100000 elementos"). Probar Algoritmos con 1000 elementos").i++){ w[i] =rand1.nanoTime(). Random rand3 = new Random().println(""). long Time = End-Start. } int[]y = new int [100000].readLine()).nextInt(150000-0).nextInt(150000-0).out.import java.nanoTime().readLine()). } int[]x = new int [10000]. long Time2 = End2-Start2. long Start = System. for(int f=0. for(int g=0.io.out.in)). long End2 = System.println("Ingrese el valor de K"). for(int i=0.length.*. } do{ try{ System.Random.K).i<w.BuscaKesimoIneficiente(w.BuscaKesimoEficiente(w. import java.util. System.length.out.parseInt(tld. int l = 0.Vector.println("1. long Start2 = System. System.out.g<y. public class Usar{ public static void main(String[]args){ BufferedReader tld = new BufferedReader(new InputStreamReader(System. Math2. System. long End = System. System.println("3.parseInt(tld.nanoTime(). Math2.out.util.nextInt(150000-0).println("2. Random rand1 = new Random().f++){ x[f] =rand2. switch(m){ case 1:{ System. int K = Integer.

int K = Integer.K).BuscarEficiente(t.println("Tiempo en nanosegundos de Busqueda del K-esimo Ineficiente es "+Time ).out.K).PotenciaIneficiente(a.nanoTime().BuscarIneficiente(t.PotenciaEficiente(a.out.0. int b = Integer. long Time6 = End6-Start6.println("Ingrese el valor de K").BuscaKesimoIneficiente(x.BuscaKesimoEficiente(x.println("Ingrese El Numero a Buscar").println("Tiempo en nanosegundos de Potencia Ineficinete es "+Time3 ).parseInt(tld.out.nanoTime().println("Tiempo en nanosegundos de Potencia Eficiente es "+Time4 ). int[]t=new int[w.println("Tiempo en nanosegundos de Busqueda Ineficiente es "+Time5 ). Math2.nanoTime().println("Ingrese El Exponente Para la potencia"). long End = System.println("Ingrese La Base Para la potencia"). long Time3 = End3-Start3. System.out. long Start5 = System. break.println("Tiempo en nanosegundos de Busqueda Eficiente es "+Time6 ).length-1).parseInt(tld. Math2.out. long Time4 = End4-Start4. System. int a = Integer.quickSort2(t.parseInt(tld. long Start = System.out. long Time5 = End5-Start5. long End4 = System.println("Tiempo en nanosegundos de Busqueda del K-esimo Eficiente es "+Time2 ). long End2 = System.nanoTime(). System. Math2. long Start6 = System.t. } Math2.readLine()).nanoTime(). Math2. System.q).out.nanoTime().out.b). long End3 = System. System.q). long Start3 = System. System. } case 2:{ System. Math2.out. System. long Time2 = End2-Start2.nanoTime().h<w. long End6 = System. long Start2 = System.out.readLine()).b). long Time = End-Start.length].h++){ t[h]=w[h]. long End5 = System. Math2.nanoTime(). . System.length.nanoTime(). for(int h=0.readLine()). long Start4 = System.nanoTime(). System.nanoTime(). int q=Integer.nanoTime().parseInt(tld.readLine()).

System. break. System.println("Tiempo en nanosegundos de Busqueda Ineficiente es "+Time5 ). System.h<x. int q=Integer.0. Math2. Math2.readLine()).length-1).quickSort2(t.t.parseInt(tld. System.K).out. long Start4 = System.out. Math2. .h++){ t[h]=x[h].b).nanoTime(). } Math2.println("Tiempo en nanosegundos de Busqueda del K-esimo Eficiente es "+Time2 ). long Start2 = System.out.parseInt(tld.println("Ingrese La Base Para la potencia").out.nanoTime(). long Time5 = End5-Start5.out.PotenciaIneficiente(a. long Start5 = System. System.out.readLine()).println("Tiempo en nanosegundos de Busqueda del K-esimo Ineficiente es "+Time ).nanoTime(). Math2.q).out.b).println("Ingrese El Exponente Para la potencia").BuscarEficiente(t. System. Math2.K).length].nanoTime().out.nanoTime(). long Time4 = End4-Start4.readLine()).q). for(int h=0. long Time6 = End6-Start6.println("Ingrese el valor de K"). int b = Integer.println("Tiempo en nanosegundos de Busqueda Eficiente es "+Time6 ).println("Ingrese El Numero a Buscar"). long End4 = System.nanoTime().out.readLine()). System.nanoTime(). long Start = System. long End = System. long Start3 = System. long End6 = System.out. long End5 = System.parseInt(tld.BuscaKesimoEficiente(y. long Time3 = End3-Start3.BuscarIneficiente(t. long End3 = System. Math2.nanoTime().nanoTime(). int[]t=new int[x. int K = Integer.nanoTime(). int a = Integer. long Time = End-Start. long End2 = System.PotenciaEficiente(a.length.println("Tiempo en nanosegundos de Potencia Eficiente es "+Time4 ). System.println("Tiempo en nanosegundos de Potencia Ineficinete es "+Time3 ).BuscaKesimoIneficiente(y.parseInt(tld. System. long Start6 = System. } case 3:{ System.nanoTime().nanoTime().

long End6 = System.length. long End3 = System. long End5 = System.parseInt(tld. System. int a = Integer.nanoTime().nanoTime().nanoTime(). long Time2 = End2-Start2.h++){ t[h]=y[h]. long End4 = System.length].BuscarEficiente(t.0.b).readLine()).parseInt(tld.println("Ingrese La Base Para la potencia").h<y.out. System. long Time5 = End5-Start5.b).println("No Se Pudo Leer El Dato").println("Tiempo en nanosegundos de Potencia Ineficinete es "+Time3 ).out. int b = Integer.println("Tiempo en nanosegundos de Busqueda Eficiente es "+Time6 ).t.println("Ingrese El Numero a Buscar").nanoTime().q). } } .PotenciaIneficiente(a.println("Tiempo en nanosegundos de Busqueda Ineficiente es "+Time5 ).nanoTime().out.nanoTime().BuscarIneficiente(t. Math2. long Time4 = End4-Start4.readLine()).out.nanoTime(). long Time6 = End6-Start6. long Start5 = System. System. for(int h=0. } }while(l==1).out.PotenciaEficiente(a. System.out. System.quickSort2(t. int q=Integer.parseInt(tld.q).nanoTime().out. long Time3 = End3-Start3. System. } Math2.println("Tiempo en nanosegundos de Potencia Eficiente es "+Time4 ).readLine()). Math2. int[]t=new int[y.out. Math2. break.println("Ingrese El Exponente Para la potencia"). long Start3 = System.println("Tiempo en nanosegundos de Busqueda del K-esimo Eficiente es "+Time2 ). System. Math2. long Start6 = System.out.length-1). System. } } }catch(IOException e){ System. long Start4 = System.

36187362% más rápido que el ineficiente.858603938% más rápido que el ineficiente. Nota: De este gráfico podemos señalar que para los distintos arreglos de prueba. el porcentaje del método de eficiencia es de un 70. 120 elevado a 25. 15 elevado a 12.6381653% más rápido que el ineficiente.  Para el arreglo de 1000 elementos el método eficiente resulta un 73. la potencia 12 elevado a 12. logrando un menor tiempo las búsquedas eficientes. 10 elevado a 12.  En el segundo caso. podemos evidenciar que en el 100% de los casos el cálculo por el método eficiente. el método eficiente resulta un 2.17894737% más rápido que el ineficiente. el método eficiente resulta un 41. este último predomina por sobre el ineficiente. Para el arreglo de 10000 elementos el método eficiente resulta un 67. Para el arreglo de 100000 elementos el método eficiente resulta un 73.  En el primer caso.36987936% por sobre el algoritmo lineal.  En el tercer caso.  En el último caso.49440716% más rápido que el ineficiente. . Nota: De este gráfico podemos recalcar que existe una gran diferencia entre los resultados de búsquedas eficientes e ineficientes. CONCLUSIONES Nota: De este gráfico de potencias.35059179% más rápido que el ineficiente. siempre resultan más factibles las soluciones eficientes. el método eficiente resulta un 37. Para el arreglo de 1000 elementos el método eficiente resulta un 89.54236336% más rápido que el ineficiente.

Para finalizar podemos señalar que para calcular el K-ésimo elemento.78354357% más rápidos que en la búsqueda ineficiente. también podemos ver que para calcular ab. y finalmente para la búsqueda del elemento los algoritmos eficientes son un 87.96286289% más rápido que el ineficiente.  Para el arreglo de 1000 elementos el método eficiente resulta un 97.  Para el arreglo de 1000 elementos el método eficiente resulta un 91.11647711% más rápido que el ineficiente.97545946% más rápidos que los ineficientes. en promedio los resultados eficientes son un 76. los algoritmos eficientes son en promedio un 37.54056779% más eficientes que los lineales. .