Professional Documents
Culture Documents
Se debe crear una nica clase llamada Math2, a la cual tenemos que implementar los mtodos
estticos 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 tamao, los cuales nos permitirn obtener los tiempos
resultantes para cada tipo de soluciones y as finalmente construir grficos que nos muestren
los resultados obtenidos.
DESARROLLO
La Clase Math2:
Una vez comprendida nuestra descripcin del problema, comenzamos a definir nuestra clase
Math2. Para solucionar el problema implementamos ocho funciones, estas son:
o La funcin BuscaKesimoIneficiente es la que encuentra el elemento k-simo,
ordenando el arreglo y entregando el elemento ingresado.
o La funcin BuscaKesimoEficiente es la que encuentra el elemento k-simo en
el cual usamos pivote y el mtodo math.ceil para redondear, y construimos un
ciclo para identificarlo.
o La funcin PotenciaIneficiente es la que encuentra el valor de la expresin pero
con un tiempo de demora mayor, o sea ineficiente.
o La funcin PotenciaEficiente es la funcin que encuentra el valor de la
expresin de potencia de forma ms rpida, o sea la ms eficiente.
o La funcin BuscarIneficiente es la que busca en el arreglo el nmero pero se
demora, en conclusin es ineficiente.
o La funcin BuscarEficiente es la que busca dentro de un arreglo un nmero y lo
hace rpidamente, sea es el ms eficiente.
o La funcin quickSort, que se invocada en la funcin de
BuscaKesimoIneficiente, y ordena los elementos del arreglo de menor a mayor.
Pgina 1 de 10
o La funcin quickSort2, que se invoca en BuscarIneficiente, y ordena los
elementos del arreglo de mayor a menor.
Cdigo:
if (k == w + 1 + menores) {
return uno[pivote];
}
else {
if (k <= w + menores) {
uno=dosMenor;
tam=w;
}
else {
uno=dosMayor;
Pgina 2 de 10
tam=z;
menores+=z+1;
}
}
pivote=(int)Math.ceil(tam/2);
}
}
}
Pgina 3 de 10
if (numero > x[pivote]) {
mayor = pivote - 1;
} else {
menor = pivote + 1;
}
}
}
return false;
}
private static void quickSort( int a[], int left, int right){
int i = left;
int j = right;
int pivot = a[(int)(left+right)/2];
do{
while(a[i]<pivot)i++;
while(a[j]>pivot)j--;
if(i<=j){
int aux = a[i];
a[i] = a[j];
a[j] = aux;
i++;
j--;
}
}while(i<=j);
if(left<j)quickSort(a,left,j);
if(i<right)quickSort(a,i,right);
public static void quickSort2( int a[], int left, int right){
int i = left;
int j = right;
int pivot = a[(int)(left+right)/2];
do{
while(a[i]>pivot)i++;
while(a[j]<pivot)j--;
if(i<=j){
int aux = a[i];
a[i] = a[j];
a[j] = aux;
i++;
j--;
}
}while(i<=j);
if(left<j)quickSort(a,left,j);
if(i<right)quickSort(a,i,right);
}
}
La Clase Usar:
En primer lugar creamos el buffered, para leer los datos que solicitar el programa al usuario; el
valor de k para calcular el k-simo, el valor de a y b para calcular ab y un valor a buscar
dentro del arreglo.
Luego implementamos un pequeo men en el cual podemos elegir probar e algoritmo entre
1000 elementos, 10000 elementos, 100000 elementos.
Pgina 4 de 10
Para cada caso, es decir, probando nuestras soluciones con arreglos de 1000, 10000 y 100000
elementos, haremos los siguientes pasos:
Comenzaremos con encontrar el K-simo elemento del arreglo, donde debemos ingresar el
valor de K, encontrarlo dentro del arreglo de forma eficiente, usando la funcin
BuscaKesimoEficiente de la Clase Math2, y lineal, usando la funcin BuscaKesimoIneficiente
de la clase Math2, y luego desplegar en pantalla los tiempos transcurridos para cada tipo de
solucin.
Codigo Fuente:
Cdigo:
import java.util.Vector;
import java.util.Random;
import java.io.*;
do{
try{
System.out.println("");
System.out.println("1. Probar Algoritmos con 1000 elementos");
System.out.println("2. Probar Algoritmos con 10000
elementos");
Pgina 5 de 10
System.out.println("3. Probar Algoritmos con 100000
elementos");
int m = Integer.parseInt(tld.readLine());
switch(m){
case 1:{
System.out.println("Ingrese el valor de K");
int K = Integer.parseInt(tld.readLine());
long Start = System.nanoTime();
Math2.BuscaKesimoIneficiente(w,K);
long End = System.nanoTime();
long Time = End-Start;
System.out.println("Tiempo en nanosegundos de Busqueda
del K-esimo Ineficiente es "+Time );
long Start2 = System.nanoTime();
Math2.BuscaKesimoEficiente(w,K);
long End2 = System.nanoTime();
long Time2 = End2-Start2;
System.out.println("Tiempo en nanosegundos de Busqueda
del K-esimo Eficiente es "+Time2 );
System.out.println("Ingrese La Base Para la
potencia");
int a = Integer.parseInt(tld.readLine());
System.out.println("Ingrese El Exponente Para la
potencia");
int b = Integer.parseInt(tld.readLine());
long Start3 = System.nanoTime();
Math2.PotenciaIneficiente(a,b);
long End3 = System.nanoTime();
long Time3 = End3-Start3;
System.out.println("Tiempo en nanosegundos de Potencia
Ineficinete es "+Time3 );
long Start4 = System.nanoTime();
Math2.PotenciaEficiente(a,b);
long End4 = System.nanoTime();
long Time4 = End4-Start4;
System.out.println("Tiempo en nanosegundos de Potencia
Eficiente es "+Time4 );
System.out.println("Ingrese El Numero a Buscar");
int q=Integer.parseInt(tld.readLine());
int[]t=new int[w.length];
for(int h=0;h<w.length;h++){
t[h]=w[h];
}
Math2.quickSort2(t,0,t.length-1);
long Start5 = System.nanoTime();
Math2.BuscarIneficiente(t,q);
long End5 = System.nanoTime();
long Time5 = End5-Start5;
System.out.println("Tiempo en nanosegundos de Busqueda
Ineficiente es "+Time5 );
long Start6 = System.nanoTime();
Math2.BuscarEficiente(t,q);
long End6 = System.nanoTime();
long Time6 = End6-Start6;
System.out.println("Tiempo en nanosegundos de Busqueda
Eficiente es "+Time6 );
break;
}
Pgina 6 de 10
case 2:{
break;
}
case 3:{
Pgina 7 de 10
long Start = System.nanoTime();
Math2.BuscaKesimoIneficiente(y,K);
long End = System.nanoTime();
long Time = End-Start;
System.out.println("Tiempo en nanosegundos de Busqueda
del K-esimo Ineficiente es "+Time );
long Start2 = System.nanoTime();
Math2.BuscaKesimoEficiente(y,K);
long End2 = System.nanoTime();
long Time2 = End2-Start2;
System.out.println("Tiempo en nanosegundos de Busqueda
del K-esimo Eficiente es "+Time2 );
System.out.println("Ingrese La Base Para la
potencia");
int a = Integer.parseInt(tld.readLine());
System.out.println("Ingrese El Exponente Para la
potencia");
int b = Integer.parseInt(tld.readLine());
long Start3 = System.nanoTime();
Math2.PotenciaIneficiente(a,b);
long End3 = System.nanoTime();
long Time3 = End3-Start3;
System.out.println("Tiempo en nanosegundos de Potencia
Ineficinete es "+Time3 );
long Start4 = System.nanoTime();
Math2.PotenciaEficiente(a,b);
long End4 = System.nanoTime();
long Time4 = End4-Start4;
System.out.println("Tiempo en nanosegundos de Potencia
Eficiente es "+Time4 );
System.out.println("Ingrese El Numero a Buscar");
int q=Integer.parseInt(tld.readLine());
int[]t=new int[y.length];
for(int h=0;h<y.length;h++){
t[h]=y[h];
}
Math2.quickSort2(t,0,t.length-1);
long Start5 = System.nanoTime();
Math2.BuscarIneficiente(t,q);
long End5 = System.nanoTime();
long Time5 = End5-Start5;
System.out.println("Tiempo en nanosegundos de Busqueda
Ineficiente es "+Time5 );
long Start6 = System.nanoTime();
Math2.BuscarEficiente(t,q);
long End6 = System.nanoTime();
long Time6 = End6-Start6;
System.out.println("Tiempo en nanosegundos de Busqueda
Eficiente es "+Time6 );
break;
}
}
}catch(IOException e){
System.out.println("No Se Pudo Leer El Dato");
}
}while(l==1);
Pgina 8 de 10
}
CONCLUSIONES
Nota: De este grfico de potencias, podemos evidenciar que en el 100% de los casos el
clculo por el mtodo eficiente, este ltimo predomina por sobre el ineficiente.
Nota: De este grfico podemos sealar que para los distintos arreglos de prueba, siempre
resultan ms factibles las soluciones eficientes.
Nota: De este grfico podemos recalcar que existe una gran diferencia entre los resultados
de bsquedas eficientes e ineficientes, logrando un menor tiempo las bsquedas eficientes.
Para finalizar podemos sealar que para calcular el K-simo elemento, en promedio los
resultados eficientes son un 76,78354357% ms rpidos que en la bsqueda ineficiente,
tambin podemos ver que para calcular ab, los algoritmos eficientes son en promedio un
37,97545946% ms rpidos que los ineficientes, y finalmente para la bsqueda del elemento
los algoritmos eficientes son un 87,54056779% ms eficientes que los lineales.
Pgina 9 de 10
Pgina 10 de 10