INDICE

1. Logaritmo entero3
1.1. Ejecucin detallada........3
1.2. Regla de traduccin...5
1.3. Algoritmo iterativo.5
1.4. Conclusiones...5

2. Bsqueda binaria (o dicotmica)...6
2.1. Ejecucin detallada..6
2.2. Regla de traduccin.8
2.3. Algoritmo iterativo...9
2.4. Conclusiones.9








2
1. Logaritmo entero. Dados dos nmeros naturales, b>1, n1, se desea hallar la
parte entera del logaritmo en base b de n.
Por ejemplo, logEntero (2,8) = 3, y logEntero (2,9) =3.

Recurdese que logbn es un nmero z tal que bz = n. Por tanto, el logaritmo
puede determinarse por divisiones sucesivas: se cuenta el nmero de veces que
puede dividirse n entre b. En Java:

Public static int logEntero1 (int b, int n)
{
If (n<b)
return 0;
Else
Return 1+logEntero1(b,n/b);
}

1.1. Ejecucin detallada.

B= 2 LOG
2
8= 3
N= 8;

Public static int logEntero1 (int 2, int 8)
{
If (8<2)
return 0;
Else
return 1+logEntero1(2,8/2);
}


public static int logEntero1 (int 2, int 4)
{
if (4<2)
return 0;
else
return(1+logEntero1(2,4/2);
}


public static int logEntero1 (int 2, int 2)
{
if (2<2)
return 0;
else
return 1+logEntero1(2,2/2);
}





1
2
1
2
3
1 + 2= 3

1 + 1= 2

1 + 0= 1

Resultado que se
retorna a la funcin
principal


3
Ingresa Argumento Entero



public static int logEntero1 (int 2, int 1)
{
if (1<2)
return 0;
}




B= 2 LOG
2
9= 3
N= 9

Public static int logEntero1 (int 2, int 9)
{
if (9<2)
return 0;
else
return 1+logEntero1(2,9/2);
} 4.5
int 4.5= 4

public static int logEntero1 (int 2, int 4)
{
if (4<2)
return 0;
else
return(1+logEntero1(2,4/2);
}


public static int logEntero1 (int 2, int 2)
{
if (2<2)
return 0;
else
return 1+logEntero1(2,2/2);
}



public static int logEntero1 (int 2, int 1)
{
if (1<2)
return 0;
}



3
0

1
2
1
2
3
3
1 + 2= 3

1 + 1= 2

1 + 0= 1

0

Resultado que se
retorna a la funcin
principal


4
Nota: Desde la primera funcin se llama a la misma hasta llegar al caso bsico,
y cuando esto se cumpla ser la ltima funcin, pero la primera de la pila en
resolverse desde la cual se ira llevando el resultado desde la funcin de caso
bsico hasta la funcin principal, pero terminando cada uno de los procesos
pendientes en la pila y acumulando ms resultados, en este algoritmo se realiza
un conteo del nmero de divisiones del nmero para la base y tal nmero ser el
logaritmo que se ha buscado.

1.1. Regla de traduccin.

Se utiliz el tercer caso particular, en donde se conoce el valor del caso bsico
B<X
n
>. La cual cumple una propiedad llamada pseudoconmutativa en la que se
puede avanzar de inicio a fin o viceversa.

1.2. Algoritmo iterativo.

Public static int logEntero1(int b, int n)
{
int base= b;
int num= n;
float log=1;
while(num > base)
{
Log= 1+ log;
num=num/base;
}
Return(Log);
}

1.3. Conclusiones.

Al pasar del algoritmo recursivo al iterativo se puede, evitar el
agotamiento de espacio en la memoria
Es un algoritmo fcil de transformar a un algoritmo iterativo donde
no hace falta tener doble estructura iterativa tanto para el momento
que se hacen las llamadas a la funcin, como cuando se regresa desde
la ltima funcin y primera en la pila trayendo resultados
















5
2. Bsqueda binaria (o dicotmica). Dado un elemento de informacin e y un vector
ordenado v y un elemento e, quiere determinarse si el elemento e se encuentra
almacenado en el vector v. En caso de encontrarse, el algoritmo debe devolver la
posicin de v donde se encuentra; en caso de no encontrarse almacenado en ninguna
posicin del vector, se devolver el valor -1.
Por ejemplo, buscar(3,{1,6,9,3,2,7}) = 3, y buscar(8,{1,6,9,3,2,7}) = -1.

En Java:

public static int buscar1 (int e, int[] v)
{
return busquedaBin (e, v, 0, v.length-1);
}


private static int busquedaBin(int e, int[] v, int inf, int sup)
{
if (inf==sup)
return (e==v[sup]?sup:-1);
else
{
int med = (inf+sup) / 2;
if (e > v[med])
return busquedaBin (e, v, med+1, sup);
else
return busquedaBin (e, v, inf, med);
}
}

2.1.Ejecucin detallada.


E=3

public static int buscar1 (int 3, int[] v)
{
return busquedaBin (3, v, 0,5);
}

private static int busquedaBin(int 3, int[] v, int 0, int 5)
{
if (0==5)
return (e==v[sup]?sup:-1);
else
{
int med = (0+5) / 2;
if (3 > 3)
return busquedaBin (e, v, med+1, sup);
else
return busquedaBin (3, v, 0, 2);
}
}

0 1 2 3 4 5
1 2 3 6 7 9
1
2
2
Este es el resultado
que se obtendr en
la funcin principal

6


Private static int busquedaBin(int 3, int[] v, int 0, int 2)
{
if (0==2)
return (e==v[sup]?sup:-1);
else
{
int med = (0+2) / 2;
if (3>2)
return busquedaBin (3, v, 2, 2);
else
return busquedaBin (e, v, inf, med);
}
}


private static int busquedaBin(int 3, int[] v, int 2, int 2)
{
if (2==2)
return (3==3?2);
}


Nota: En este algoritmo las llamadas a las funciones para
la bsqueda binaria se lo realiza hacienda un mtodo de
biseccin entre un lmite superior y uno inferior y un
punto medio, para esto cuando se encuentre el numero en
alguna de las posiciones del vector nos retornara la
posicin del nmero, en nuestro cdigo lo que se retorna es
el lmite superior, podramos retornar tambin el lmite
inferior ya que los dos limites van a estar ubicados en la
misma posicin del nmero buscado, mientras que si no
existe tal nmero buscado en el vector retornara su
resultado a cada uno de las funciones llamadas.


Cuando no se encuentra un elemento dentro del vector



E=8



public static int buscar1 (int 8, int[] v)
{
return busquedaBin (8, v, 0,5);
}



0 1 2 3 4 5
1 2 3 6 7 9
1
2
2
2
2
-1
Resultado -1 ya
que no se encontr
tal numero en el
vector

7




private static int busquedaBin(int 8, int[] v, int 0, int 5)
{
if (0==5)
return (e==v[sup]?sup:-1);
else
{
int med = (0+5) / 2;
if (8>3)
return busquedaBin(8,v,3,5);
else
return busquedaBin (e, v, inf, med);
}
}


private static int busquedaBin(int 8, int[] v, int 3, int 5)
{
if (3==5)
return (e==v[sup]?sup:-1);
else
{
int med = (3+5) / 2;
if (8>7)
return busquedaBin(8,v,5,5);
else
return busquedaBin (e, v, inf, med);
}
}



private static int busquedaBin(int 8, int[] v, int 5, int 5)
{
if (5==5)
return (8==9?sup:-1);
}


2.2.Regla de traduccin.

Se utiliz El primer caso Particular, Recursividad final ya que el proceso se lo ha
realizado dentro de una sola estructura iterativa que es el while.





1
1
2
2
-1
-1
-1

8
2.3.Algoritmo iterativo.

public static int buscar1 (int e, int[] v)
{
return busquedaBin (e, v, 0, v.length-1);
}

private static int busquedaBin(int e, int[] v, int inf, int sup)
{
int limsup= sup;
int liminf= inf;
int numbusq= e;

while(liminf != limsup)
{
int med = (liminf+limsup) / 2;
if (numbusq > v[med])
liminf= med+1;
else
limsup= med;
}
return (numbusq ==v[limsup]?limsup:-1);
}


2.4.Conclusiones.

Es un algoritmo bien implementado, pero a la vez limitado ya que si
se tiene un nmero que se repite ms de una vez va a devolver el la
primera posicin en la que se encuentre
Al ser realizado con el primer caso particular solo hace falta realizar
una estructura de iteracin almacenando resultados.