REC0RSIvIBAB Pgina

kLCUk5IVIDAD
REC0RSIvIBAB Pgina






CATEDRTICO: ING. ROSEL MUOZ LOPEZ

ESTRUCTURA DE DATOS



INTEGRANTES:
ZURIDIANA ROXETTE MORALES SANTIAGO
RUMUALDA ALCAZAR ALTUZAR


TAPACHULA, CHIAPAS A 12 DE JUlIO DEL 2011.

INSTITUTU TECNULUCICU DE
TAPACHULA
REC0RSIvIBAB Pgina

INTRODUCCION



El mtodo recursivo es un mtodo que se llama as mismo directa o
indirectamente. Existen dos clases de recursividad que son: la recursividad o
recursin directa que es el proceso de por el que un mtodo se llama as mismo
desde el propio cuerpo del mtodo, y la recursividad o recursin indirecta implica
mas d un mtodo. La recursividad indirecta implica que la existencia de dos
mtodos: uno() y dos (). Entonces desde el main () llama a uno (), y a continuacin
uno () llama a dos (). En alguna parte del proceso dos () llama a uno (), una
segunda llamada a uno (). Esta accin es recursin indirecta, por eso es recursiva,
ya que uno () ha sido llamado dos veces, sin retornar nunca a su llamadora.
Los bucles son uno de los pilares fundamentales de la programacin, sin embargo,
es posible construir programas sin utilizarlos.
La recursividad simplemente significa aplicar una funcin como parte de la
definicin de esa misma funcin.
La clave de funcionamiento es que obligatoriamente debe existir una condicin
terminal con el objeto de que la funcin se bifurque hacia una resolucin no
recursiva en algn punto. De lo contrario, la funcin entra en un bucle infinito y
nunca finaliza.









REC0RSIvIBAB Pgina

|(|
1eua,

|
|ec|r|v|dad de-|n|c|on

1|no de rec|r|v|dad en |
coun|e+|dad -

||nc|on
rec|r|va

/|nac|on de ueuor|a e!a!|ca V
d|nu|ca4(

(uo -|nc|onan |o a|or|!uo de rec|r|v|dad
47

|ron|edade de a|or|!uo rec|r|vo
42

(adena rec|r|va o rec|r|v|dad |nd|rec!a
4

|a !or de
|an|47

|ec|r|on \
!erac|on74



|+eun|o de rec|r|v|dad

4 ||enado de |n
arre|o72
7 (a|c||ar n(r
7A
REC0RSIvIBAB Pgina

2 unr|ue 2 vece
|o|a7
A ||uo coun |v|or 7n|uero en!ero no|!|v
7(
||uo coun |v|or 7n|uero en!ero no|!|vo(d|-eren!e
||ca`77
( |aVor de n nuero en!ero no|!|vo
7-
7 |enor de n nuero en!ero
no|!|vo 7
- den!|-|ca | |n n|uero en!ero no|!|vo e nar o
|unar 2(
/
n

24
4( (rdenau|en!o rn|do Q||c|:or!
27
44 :|ua de n ||uero |n!ero
2A
47 (enera e |unr|ue e| a|ecedar|o en uaVc||a
2


RECURSIVIDAD

Un mtodo recursivo es aquel que se llama a s mismo, bien directamente o bien a
travs de otro mtodo.
Recursividad es una tcnica de programacin importante. Se utiliza para realizar
una llamada a una funcin desde la misma funcin. Recursividad y la iteracin
(ejecucin en bucle) estn muy relacionadas, cualquier accin que pueda
realizarse con la recursividad puede realizarse con iteracin y viceversa.

La recursin en los subprogramas puede darse de dos maneras diferentes:

a) Directa: el subprograma se llama directamente a s mismo. Por ejemplo, un
subprograma y en alguna parte de el aparece una llamada a s mismo.





LIamada a P

Subprograma P
REC0RSIvIBAB Pgina






b) Indirecta: el subprograma llama a otro subprograma, y este a su vez llama
al primero. Por ejemplo, el subprograma P llama al subprograma Q y este a
su vez invoca al primero (fig. 1).
Tambin se da la recursin indirecta cuando el subprograma llama a otro y
este a un tercero. Una vez ejecutado, el control regresa al subprograma que
lo llamo; lo mismo sucede en todos sus niveles. Por ejemplo, el
subprograma P que llama al subprograma Q, y este llama al subprograma
V. Cuando V concluye, el control regresa a Q, y al terminar este, el control
se transfiere a P (fig.2)
















Es fcil crear una funcin recursiva que no llegue a devolver nunca un resultado
definitivo y no pueda llegar a un punto de finalizacin. Este tipo de recursividad
hace que el sistema ejecute lo que se conoce como bucle "infinito".


Llamada a O
8ubprograma P
8ubprograma O
Llamada a P
8ubprograma P
8ubprograma O
8ubprograma V
Llamada a O
Llamada a V

lla 1
lla 2
REC0RSIvIBAB Pgina

pub||c c|ass kecur|v|dad // se dec|ara |a c|ase

stat|c |nt mtodo(|nt a) // este es un mtodo recurs|vo donde su parmetro a adqu|ere
e| va|or de x

a++ // se |ncrementa |a var|ab|e a
return mtodo(a) // este es e| ||amado a| mtodo as| m|smo donde no t|ene f|n

pub||c stat|c vo|d ma|n(str|ng arg ) // este es e| metodo ma|n donde [ava e[ecuta |os
programas

|nt x // dec|arac|on de una var|ab|e |oca| x de| mtodo ma|n
xIntegerparseInt(ICpt|onaneshowInputD|a|og(nu||"|ntroduaca numero"))
// ped|mos e| va|or de x
metodo(x) // se manda a ||amar a| mtodo stat|co



Los parmetros y variables locales toman nuevos valores en cada llamada (no se
trabaja con los anteriores). Un procedimiento o funcin se dice recursivo si durante
su ejecucin se invoca directa o indirectamente a s mismo. Esta invocacin
depende al menos de una condicin que acta como condicin de corte que
provoca la finalizacin de la recursin.

Un algoritmo recursivo consta de:
1- Al menos un caso trivial o base, es decir, que no vuelva a invocarse y que se
ejecuta cuando se cumple cierta condicin, y
2- el caso general que es el que vuelve a invocar al algoritmo con un caso ms
pequeo del mismo.

pub||c c|ass kecur|v|dad // se dec|ara |a c|ase

stat|c |nt mtodo(|nt a) // este es un mtodo recurs|vo donde su parmetro a adqu|ere
e| va|or de x

If(a0) // este es una sentenc|a de contro| para f|na||zar |a recurs|v|dad

a // se |e resta 1 a| va|or de |a var|ab|e a
// a este se |e denom|na caso base por qu no se vue|ve a |nvocar a|
m|smo mtodo

L|se

REC0RSIvIBAB Pgina 8

return mtodo(a) // este es e| ||amado a| mtodo as| m|smo donde no
t|ene f|n
// 1amb|n se |e denom|na caso GLNLkAL por que se ||ama as| m|smo


pub||c stat|c vo|d ma|n(str|ng arg ) // metodo ma|n donde [ava e[ecuta |os programas

|nt x // dec|arac|on de una var|ab|e |oca| x de| mtodo ma|n
xIntegerparseInt(ICpt|onaneshowInputD|a|og(nu||"|ntroduaca numero"))
// ped|mos e| va|or de x
metodo(x) // se manda a ||amar a| mtodo stat|co









TIPOS DE RECURSIVIDAD SEGN SU COMPLEJIDAD
1. Recursin IineaI: Un mtodo recursivo es lineal, si como mximo tiene una
llamada recursiva por rama del condicional, de manera que la cantidad de
llamadas recursivas puede calcularse como una funcin lineal que
depender de la velocidad con la cual progresa hacia el caso base. sta a
su vez la subdividimos en:

1. Recursin por Ia coIa: es cuando la llamada recursiva se hace al
final del mtodo, no quedan operaciones pendientes sobre los datos,
de manera que no hace falta representar con una pila las variables
de cada llamada, y el mtodo recursivo lo podramos transformar
tranquilamente en un bucle iterativo.

2. Recursin no por Ia coIa: es cuando despus de ejecutar todas las
llamadas recursivas el mtodo debe realizar una operacin
pendiente para completar el proceso.
REC0RSIvIBAB Pgina 9


2. Recursin no IineaI: Un mtodo recursivo es no lineal, si hay ms de una
llamada recursiva por rama del condicional.

1. Recursin en cascada: es cuando en cada rama hay ms de una
llamada a la funcin recursiva, su complejidad en trmino de
llamadas recursivas ser una funcin exponencial de la profundidad
del rbol de las llamadas.

2. Recursin anidada: es cuando alguna llamada recursiva recibe
como parmetro a una llamada recursiva, su complejidad en trmino
de llamadas recursivas resultar mucho ms difcil de calcular.


3. Recursin mutua: se da cuando dos funciones son recurrentes entre s.

FUNCION RECURSIVA

Las funciones recursivas se componen de:
Caso base: una solucin simple para un caso particular (puede
haber ms de un caso base). La secuenciacin, iteracin condicional
y seleccin son estructuras vlidas de control que pueden ser
consideradas como enunciados.

Caso recursivo: una solucin que involucra volver a utilizar la
funcin original, con parmetros que se acercan ms al caso base.
Los pasos que sigue el caso recursivo son los siguientes:

O El procedimiento se llama a s mismo
REC0RSIvIBAB Pgina

O El problema se resuelve, resolviendo el mismo problema pero de
tamao menor
O La manera en la cual el tamao del problema disminuye asegura que
el caso base eventualmente se alcanzar










A5IGNACICN L51A1ICA DINAMICA DL LA MLMCkIA

Al ejecutar una aplicacin Java, la memoria usada por la aplicacin se divide en

distintas zonas:
REC0RSIvIBAB Pgina


Fig. 3 Esquema en el que se divide la memoria en un programa recursivo.
Programas:
En una zona de memoria se cargan los bytecodes correspondientes a las clases
que forman parte de la aplicacin.

Zona esttica.
Donde se almacenan las variables de clase (declaradas con static)
O Datos compartidos (datos globales).
O Datos que han de mantenerse ms all de la duracin de la invocacin de
un mtodo o de la vida de un objeto.
Pila.
Donde se almacenan las variables locales (y parmetros) de los mtodos que se
invocan.

O Cada llamada a un mtodo provoca que se reserve espacio en la pila para
almacenar sus variables locales (y los valores de sus parmetros).
O Al finalizar la ejecucin del mtodo, se libera el espacio ocupado en la pila
por las variables locales del mtodo.

REC0RSIvIBAB Pgina

Esta zona de memoria se denomina pila, por la forma que evoluciona su estado:

Fig. 4 Representacin de una pila en el manejo de memoria recursiva.










REC0RSIvIBAB Pgina

CMO FUNCIONAN LOS ALGORITMOS RECURSIVOS

Para entender cmo funciona la recursividad es necesario que tengamos presente
las reglas y los tipos de pasaje de parmetros provistos en JAVA.

Si un procedimiento o funcin 5 invoca a otro 6, durante la ejecucin de 6 se
reservarn locaciones de memoria para todas las variables locales de 6 y para los
parmetros pasados por valor. Al terminar la ejecucin de 6 este espacio es
desocupado. Ahora bien, si durante la ejecucin de 6 se produce una llamada a s
mismo, tendremos una segunda "instancia de 6 en ejecucin, la primera instancia
se suspende hasta que la instancia recursiva termine. Antes de iniciarse la
ejecucin recursiva de 6, se ocupan nuevas locaciones de memoria para las
variables locales y parmetros por valor de 6. Cualquier referencia a estas
variables acceder a estas locaciones. Las locaciones reservadas durante la
ejecucin inicial de 6 son inaccesibles para la 2da. nstancia de 6.

Cuando la 2da. instancia de 6 termine, el control vuelve a la primera instancia de
6, exactamente al lugar siguiente a la llamada recursiva. Cualquier referencia a las
variables locales o parmetros por valor de 6 acceder a las locaciones
reservadas inicialmente, inaccesibles para la segunda instancia de 6.

Como vemos, no se conoce la cantidad de memoria que va a utilizarse al ejecutar
un procedimiento o funcin recursivo sino que se produce una asignacin
dinmica de memoria, es decir, a medida que se producen instancias nuevas, se
van "apilando las que quedan pendientes: se ponen al menos tres elementos en
la pila:

O una para la direccin de vuelta,
O otra para el/los parmetro/s formal/es y
O otra para el identificador de la funcin que en esencia es un parmetro
pasado por variable.

Cuando la ltima instancia de la recursin - elige el caso base- se cumple, se
"desapila esa instancia y el control vuelve a la instancia anterior; as hasta
"desapilar todas las instancias.

Esta "pila que se va generando en memoria es importante tenerla en cuenta por
lo que debemos asegurarnos que el algoritmo recursivo no sea divergente.



REC0RSIvIBAB Pgina

PROPIEDADES DE ALGORITMOS RECURSIVOS:

O Un requisito importante para que sea correcto un algoritmo recursivo es que
no genere una secuencia infinita de llamadas as mismo. Claro que
cualquier algoritmo que genere tal secuencia no termina nunca.

O Una funcin 1se debe llamar asi mismo y no debe de contener ningn bucle
repetitivo (while, do while o for).

O Una funcin recursiva 1debe definirse en trminos que no impliquen a 1al
menos en un argumento o grupo de argumentos. Debe existir una "salida
de la secuencia de llamadas recursivas.

O Si en esta salida no puede calcularse ninguna funcin recursiva. Cualquier
caso de definicin recursiva o invocacin de un algoritmo recursivo tiene
que reducirse a la larga a alguna manipulacin de uno o casos ms simples
no recursivos.

La recursividad es una tcnica de programacin importante. Se utiliza para realizar
una llamada a una funcin desde la misma funcin. Como ejemplo til se puede
presentar el clculo de nmeros factoriales. l factorial de 0 es, por definicin, 1.
Los factoriales de nmeros mayores se calculan mediante la multiplicacin de 1 *
2 *..., incrementando el nmero de 1 en 1 hasta llegar al nmero para el que se
est calculando el factorial.




EJEMPLO PROGRAMA QUE CALCULA EL FACTORAL.


0! = 1
1! = 1
2! = 2 2! = 2 * 1!
3! = 6 3! = 3 * 2!
4! = 24 4! = 4 * 3!
5! = 120 5! = 5 * 4!




REC0RSIvIBAB Pgina
























Esta es la definicin recursiva de la funcin factorial, ya que se define en trminos
de si misma. La primera regla de la definicin, o caso base, establece la condicin
de terminacin. Las definiciones recursivas nos permiten definir un conjunto infinito
de objetos mediante una sentencia finita.









|n! -ac!or|a| (|n! n`
cou|en,a
| n ( en!once
rerea 4
o!ro
rerea -ac!or|a| (n
4`n
!eru|na
n||||c |n! -ac!or|a| (|n! n`
|- n ( re!|rn 4;
e|e
re!|rn -ac!or|a| (n4`
n;

A continuacin se puede ver la secuencia de factoriales.

(] 4
4] 4
7] 7
2] (
A] 7A
] 47(

|]
N * (N 1)!
5 * 24 5 * 4!
4 * 6 4 * 3!
3 * 2 3 * 2!
2 * 1 2 * 1!
1 * 1 1 * 0!
REC0RSIvIBAB Pgina

CADENAS RECURSIVAS O RECURSIVIDAD
INDIRECTA

Son algoritmos donde una funcin provoca una llamada a s misma de forma
indirecta, a travs de otras funciones.

Una funcin recursiva no necesita llamarse a s misma de manera directa. En su
lugar, puede hacerlo de manera indirecta como en el siguiente ejemplo:

a (formaI parameters) b (formaI parameters)
{ {
. .
b (arguments); a (arguments);
. .
} /*fin de a*/ } /*fin de b*/
La recursividad indirecta es aquella que se llama asi mismo pero tambin puede
llamar a otro mtodo recursivo dentro del primero mtodo, como en el ejemplo
anterior el mtodo a llama el mtodo b dentro de su estructura y el mtodo b llama
al mtodo a tambin dentro de su estructura. Claro que un mtodo recursivo
tambin tienen que ser finito.



















REC0RSIvIBAB Pgina

Un ejemplo de recursividad indirecta es el de calcular si un nmero es primo o no.


n||||c c|a |r|uo

!a!|c |n! ,4;
!a!|c |n! nr|(|n! c`

,;
|-(,<`
re!|rn ec(c`;
e|e
re!|rn (;

!a!|c |n! ec(|n! V`

|-(V,(`
re!|rn 4;
e|e
re!|rn nr|(V`;

n||||c !a!|c vo|d ua|n(:!r|n ar[1`

|n! ;
n!eernaren!(,(n!|on|ane|onn|!|a|o(n|||,n!rod|ca
||uero``;
|-(nr|(`(`
,(n!|on|ane|o|eae|a|o(n|||,|| ||uero |: |r|uo`;
e|e
,(n!|on|ane|o|eae|a|o(n|||,|| ||uero |( e
|r|uo`;



En el cdigo anterior la clase primo esta constituida por dos mtodos recursivos
los cuales son pri(int q) con parameto entero q y el segundo es sec(int y) con
parmetro y, que al momento de ejecutarlo, en el main se crea una variable local x
la cual nos pide un valor, despus de asignarle un valor entero a x entrasmos una
condicin en la cuan dentro de la condicin mandamos a llamar al primero mtodo
(pri(x)) el cual le pasamos el valor de x y q lo recibe y dentro del primer mtodo
hay otra condicin si es verdadera manda a llamar al segundo mtodo (sec(q)) al
cual le pasamos el valor de q y dentro del segundo mtodo madamos a llamar el
REC0RSIvIBAB Pgina 8

primer mtodo y asi sucesivamente hasta que la recursividad llegue a su fin y nos
devuelva un valor.
PROBLEMA DE LAS TORRES DE HANOI:

A continuacin se ver cmo pueden usarse tcnicas recursivas para lograr una
solucin lgica y elegante de un problema que no se especifica en trminos
recursivos. EL problema es el de "las torres de Hani", cuyo planteamiento inicial
se muestra en la figura a continuacin...



Fig. 5 Representacin de la torre de Hani.

Hay tres postes: 1, 2 y 3. En el poste 1 se ponen tres discos de dimetro diferente
de tal manera que un disco de dimetro mayor siempre queda debajo de uno de
dimetro menor. El objetivo es mover los discos al poste 3 usando el poste 2 como
auxiliar.

Slo puede moverse el disco superior de cualquier poste a otro poste, y un disco
mayor jams puede quedar sobre uno menor. Considrese la posibilidad de
encontrar una solucin. En efecto, ni siquiera es claro que exista una.

Ahora se ver si se puede desarrollar una solucin. En lugar de concentrar la
atencin en una solucin para tres discos, considrese el caso general de 3
discos. Supngase que se tiene una solucin para (3 1) discos y que en
trminos de sta, se pueda plantear la solucin para (3 1) discos. El problema se
resolvera entonces. Esto sucede porque en el caso trivial de un disco (al restar 1
de 3de manera sucesiva se producir, al final, 1) la solucin es simple: slo hay
que el nico disco del poste 1 a 3. As se habr desarrollado una solucin
REC0RSIvIBAB Pgina 9

recursiva si se plantea una solucin para 3 discos en trminos de (3 1).
Considrese la posibilidad de encontrar tal relacin.
Para el caso de cinco discos en particular, supngase que se conoce la forma de
mover cuatro de ellos del poste 1 al otro, de acuerdo con las reglas. Cmo puede
completarse entonces el trabajo de mover el quinto disco? Cabe recordar que hay
3 postes disponibles.


Supngase que se supo cmo mover tres discos del poste 1 al 3. Entonces, se
pondr mover stos exactamente igual hacia 2 usando el 3 como auxiliar. Esto da
como resultado la situacin los dos primeros discos en el poste B, el mayor en 1 y
en 3 ninguno. Entonces podr moverse el disco mayor de 1 a 3 y por ltimo
aplicarse de nuevo la solucin recursiva para dos discos para moverlo de 2 a 3,
usando el poste 1 como auxilia. Por lo tanto, se puede establecer una solucin
recursiva de las torres de Hani como sigue:

Para mover 3discos de 1 a 3 usando 2 como auxiliar:

O Si 31, mover el disco nico de A a C y parar.
O 2. Mover el disco superior de A a B 31 veces, usando C como auxiliar.
O 3. Mover el disco restante de A a C.
O 4. Mover los disco 3de B a C usando A como auxiliar





REC0RSIvIBAB Pgina


Fig. 6 Solucin de las torrs de Hani con 3 discos
REC0RSIvIBAB Pgina

Cdigo de Ias torres de Hani.



n||||c c|a 1orre

nr|va!e !a!|c |n! con!ador(,d|co(;
:!r|n cadena ;
nr|va!e |n! uoverd|co(|n! a, |n! |`

cadenacadena|over |co de |a 1orre ((a`` |ac|a |a !orre
((|``=n;
,(n!|on|ane|o|eae|a|o(n|||,cadena`;
con!ador;
re!|rn (;

nr|va!e |n! uover!orre(|n! n, |n! dede, |n! |ac|a, |n! n|v`

|-(n<7`

uoverd|co(dede,|ac|a`;

e|e

uover!orre(n4,dede,n|v,|ac|a`;
uoverd|co(dede,|ac|a`;
uover!orre(n4,n|v,|ac|a,dede`;

re!|rn (;

n||||c !a!|c vo|d ua|n(:!r|n ar [1`

1orre c|a|ene 1orre(`;
d|con!eernaren!(,(n!|on|ane|onn|!|a|o(n|||,||uero de
|co,1(|||: |
|/|(,,(n!|on|ane||(||/1(|||::/(|``;
,(n!|on|ane|o|eae|a|o(n|||,:e |eo|ver nara d|co
|co (`,1(||| | |/|(,
,(n!|on|ane||(||/1(|||::/(|`;
c|a|euover!orre(d|co,4,2,7`;
,(n!|on|ane|o|eae|a|o(n|||,|e|e|!o en con!ador
uov|u|en!o(` ,1(|||: | |/|(,
,(n!|on|ane||(||/1(|||::/(|`;


REC0RSIvIBAB Pgina



RECURSION VS. ITERACION
Repeticin
teracin: ciclo explcito
Recursin: repetidas invocaciones a mtodo
Terminacin
teracin: el ciclo termina o la condicin del ciclo falla
Recursin: se reconoce el caso base
En ambos casos podemos tener ciclos infinitos
Considerar que resulta ms positivo para cada problema
la eleccin entre eficiencia (iteracin) o una buena ingeniera de software, La
recursin resulta normalmente ms natural.












REC0RSIvIBAB Pgina




EJEMPLOS DE
RECURSIVIDAD

REC0RSIvIBAB Pgina

kCGkAMA kLCUk5IVC CUL nACL LL LLLNADC DL UN AkkLGLC LC IMkIML LN UNA 5CLA
VLN1ANA 1AM8ILN LA IMkIML Ck AkkLGLC


publlc class Arrealo

sLaLlc SLrlna aLlena
sLaLlc lnL xz1Lam
sLaLlc SLrlna llena(lnL w)

lf(w0)
else

z++
Llenaz!CpLlonaneshowlnpuLulaloa(nulllnLrodusca numero)
aa+Arrealo +z+ +Llenaz+n
llena(w1)

reLurn a

sLaLlc vold lmprl()

for(lnL s0sLams++)

!CpLlonaneshowMessaaeulaloa(nullArrealo +s+ +Llenas)


publlc sLaLlc vold maln(SLrlna a)

LamlnLeaerparselnL(!CpLlonaneshowlnpuLulaloa(nullCuAn1CS nuML8C uLSLA
AC8LCA8))
Llena new SLrlna Lam
!CpLlonaneshowMessaaeulaloa(nullLL A88LCLC LS nn+llena(Lam))
lmprl()









REC0RSIvIBAB Pgina

CALCULA LA5 CCM8INACICNL5 MA1LMA1ICA5 nCr


public class Combinaciones_n_C_r
{
static int com(int n,int r)
{
if(r==0 || n==0)
{
return 1;
}
else
{
if(r==0)
{
return n;
}
else
{
return com(n-1,r)+com(n-1,r-1);
}
}
}
public static void main (String arg[])
{
int a,b;
a=nteger.parsent(JOptionPane.shownputDialog(null,"ntroduaca Numero N"));
b=nteger.parsent(JOptionPane.shownputDialog(null,"ntroduaca Numero r"));
JOptionPane.shownputDialog(null,"Combunatorio "+a+" C "+b+" = "+com(a,b));
}
}









REC0RSIvIBAB Pgina

L51L kCGkAMA IMkIML nCLA 3 VLCL5 LULGC 5L 5ALL DICILNDC 5nAC



public class mpre_Hola
{
void imp(int z)
{
if(z<3)
{
JOptionPane.showMessageDialog(null,"HOLA ");
imp(z+1);
}
else
JOptionPane.showMessageDialog(null,"SHAO");
}
public static void main(String arg[])
{
mpre_Hola o=new mpre_Hola();
o.imp(0);
}
}













REC0RSIvIBAB Pgina

L51L kCGkAMA CALCULA LL MAkICC CCMUN DIVI5Ck DL 2 NUMLkC C5I1IVC5


public class MaxCD
{
static int MCD(int a, int b)
{
if(a!=b)
{
if(a>b)
{
a=a-b;
}
else
{
b=b-a;
}
return MCD(a,b);
}
return a;
}
public static void main(String arg[])
{
MaxCD a=new MaxCD();
int p,q;
p=nteger.parsent(JOptionPane.shownputDialog(null,"nttodusca primer numero"));
q=nteger.parsent(JOptionPane.shownputDialog(null,"ntrodusca segundo
numero"));
JOptionPane.showMessageDialog(null,"el maximo comun divisor es: " +MCD(p, q));
}
}









REC0RSIvIBAB Pgina 8

L51L kCGkAMA CALCULA LL MAkIMC CCMUN DIVI5Ck DL 2 NUMLkC LN1LkC5 C5I1IVC5
(DIILkLN1L LCGICA)

public class MaxComDiv
{
static int mcd(int m,int n)
{
if(n<=m && m%n==0)
return n;
else
if(m<n)
return mcd(n,m%n);
else
return mcd(n,m%n);
}
public static void main(String arg[])
{
MaxComDiv o = new MaxComDiv();
int m,n;
do
{
m=nteger.parsent(JOptionPane.shownputDialog(null,"NTRODUSCA EL
PRMER NUMEO"));
n=nteger.parsent(JOptionPane.shownputDialog(null,"NTRODUSCA SEGUNDO
NUMERO"));
}
while(n<=0 || m<=0);
JOptionPane.showMessageDialog(null,"EL MAXMO COMUN DVSOR ES:
"+mcd(m,n));
}
}










REC0RSIvIBAB Pgina 9

L51L kCGkAMA 8U5CA LL MACk DL N NUMLkC5 LN1LkC5


public class Mayor_n
{
static int i=-1,tn,a[],x;
public void cap()
{
tn=nteger.parsent(JOptionPane.shownputDialog(null,"CUANTOS NUMERO"));
a=new int [tn];
JOptionPane.showMessageDialog(null,"EL MAYOR ES "+mayor());
}
static int mayor()
{
i++;
if(i<tn)
{
a[i]=nteger.parsent(JOptionPane.shownputDialog(null,"ntodusca Numero"));
if(x<a[i])
{
x=a[i];
return mayor();
}
return mayor();
}
return x;
}
public static void main(String arg[])
{
Mayor_n o=new Mayor_n();
o.cap();
}
}









REC0RSIvIBAB Pgina

L51L kCGkAMA CALCULA LN MLNCk DL N NUMLkC C5I1IVC5
pubIIc cIuss Menor_n
{
sIuIIc InI I-1,In,u||,x:
pubIIc voId cup()
{
InInIeger.purseInI(]OpIIonPune.showInpuIDIuIog(nuII,"CUANTOS NUMLBO")):
unew InI |In|:
]OpIIonPune.showMessugeDIuIog(nuII,"LL MLNOB LS "+menor()):
}
sIuIIc InI menor()
{
I++:
II(I<In)
{
u|I|InIeger.purseInI(]OpIIonPune.showInpuIDIuIog(nuII,"InIoduscu
Numero")):
II(I0)
{
xu|I|:
reIurn menor():
}
eIse
{
II(x>u|I|)
{
xu|I|:
reIurn menor():
}
eIse
{
reIurn menor():
}
}
}
reIurn x:
REC0RSIvIBAB Pgina

}
pubIIc sIuIIc voId muIn(SIrIng urg||)
{
Menor_n onew Menor_n():
o.cup():
}
}

L51L kCGkAMA CALCULA 5I UN NUMLkC L5 Ak C IMAk



public class Par_npar
{
public int pi(int x)
{
if(x%2==0)
{
return 0;
}
else
{
return 1;
}
}
public static void main(String arg[])
{
int z;
Par_npar p=new Par_npar();
z=nteger.parsent(JOptionPane.shownputDialog(null,"NTRODUSCA NUMERO"));
if(p.pi(z)==0)
{
JOptionPane.showMessageDialog(null,"EL NUMERO ES PAR");
}
else
{
JOptionPane.showMessageDialog(null,"EL NUMERO NO PAR");
}
}
}



REC0RSIvIBAB Pgina







L51L kCGkAMA CALCULA UN NUMLkC LLLVADC A LA C1LNCIA N ( k
N
)


pubIic cIass Potencia_de_un_numero
{
static int potencia(int x,int y)
{
if(y==0)
{
return 1;
}
eIse
{
return x*potencia(x,y-1);
}
}
pubIic static void main(String arg[])
{
int a,b;
a=Integer.parseInt(JOptionPane.showInputDiaIog(nuII,"Introduaca Numero"));
b=Integer.parseInt(JOptionPane.showInputDiaIog(nuII,"Introduaca Potencia"));
JOptionPane.showInputDiaIog(nuII,"ResuIatado "+a+" ^ "+b+" =
"+potencia(a,b));
}
}







REC0RSIvIBAB Pgina

L51L kCGkAMA L5 UN ML1CDC DL CkDLNAMILN1C kAIDC CCN kLCUk5IVIDAD 1L CkDLNA
DL MLNCk A MCk DL UNA 5LkIL DL NUMLkC5 LN1LkC5 C5I1IVC5
publlc class CulcksorL

publlc vold capLura()

lnL n a
SLrlna c
nlnLeaerparselnL(!CpLlonaneshowlnpuLulaloa(nullCuanLos elemenLos a ordenar))
anew lnLn
for(lnL x0 xn x++)

axlnLeaerparselnL(!CpLlonaneshowlnpuLulaloa(nulllnLrodusca el numero +x))
lf(xn1)
qulcksorL(a0n1)

cLos numeros ordenados sonn
for(lnL x0 xn x++)

cc+Arrav+x++ax+n

!CpLlonaneshowMessaaeulaloa(null+c)

























REC0RSIvIBAB Pgina

vold qulcksorL(lnL a lnL prlmero lnL ulLlmo)

lnL l [ cenLral
lnL plvoLe
cenLral(prlmero + ulLlmo)/2
plvoLeacenLral
lprlmero
[ulLlmo
do

whlle (alplvoLe)

l++

whlle (a[plvoLe)

[

lf(l[)

lnL Lmp
Lmpal
ala[
a[Lmp
l++
[


whlle(l[)
lf(prlmero[)
qulcksorL(aprlmero[)
lf(lulLlmo)
qulcksorL(alulLlmo)

publlc sLaLlc vold maln(SLrlna ar)

CulcksorL obnew CulcksorL()
obcapLura()






REC0RSIvIBAB Pgina

L51L kCkAMA CALCULA LA 5UMA DL N NUMLkC LN1LkC5 C5I1IVC5

n||||c c|a :|un

|n! ,;
n||||c |n! |u(|n! `

,n!eernaren!(,(n!|on|ane|onn|!|a|o(n|||,n!rod|ca
||euro``;
|-(4`
re!|rn ,;
e|e
re!|rn , |u(4`;

n||||c !a!|c vo|d ua|n (:!r|n ar [1`

|n! a;
:|un o| ne :|un (`;

an!eernaren!(,(n!|on|ane|onn|!|a|o(n|||,(|/|1(:
|||||(:``;

,(n!|on|ane|o|eae|a|o(n|||,|/ :||/ |:, o||u(a``;












REC0RSIvIBAB Pgina


L51L kCGkAMA 1L INkIML LL A8LCLDAkIC LN MAU5CULA DL LA A 2



n||||c c|a a|-a|e!o

!a!|c :!r|n a;
n||||c !a!|c vo|d ua|n (:!r|n [1 ar`

ue!odo/(7`;
,(n!|on|ane|o|eae|a|o(n|||,a`;

!a!|c vo|d ue!odo/(c|ar c`

|- (c`/`

ue!odo|(c`;
aa c ;


!a!|c vo|d ue!odo|(c|ar c`

ue!odo/(c`;