Beruflich Dokumente
Kultur Dokumente
c
c
!
"
C++ permite la recursividad. Cada vez que se llama a una función, se crea un
juego de variables locales, de este modo, si la función hace una llamada a si
misma, se guardan sus variables y parámetros, usando la pila, y la nueva instancia
de la función trabajará con su propia copia de las variables locales. Cuando esta
segunda instancia de la función retorna, recupera las variables y los parámetros
de la pila y continua la ejecución en el punto en que había sido llamada.
Por ejemplo:
El factorial se simboliza como n!, se lee como "n factorial", y la definición es:
De modo que una función bien hecha para cálculo de factoriales debería incluir un
control para esos casos:
Veamos paso a paso, lo que pasa cuando se ejecuta esta función, por ejemplo:
factorial(4):
1a Instancia
n=4
n>1
salida ĸ 4 * factorial(3) (Guarda el valor de n = 4)
2a Instancia
n>1
salida ĸ 3*factorial(2) (Guarda el valor de n = 3)
3a Instancia
n>1
salida ĸ 2*factorial(1) (Guarda el valor de n = 2)
4a Instancia
n == 1 ĺ retorna 1
3a Instancia
(recupera n=2 de la pila) retorna 1*2=2
2a instancia
(recupera n=3 de la pila) retorna 2*3=6
1a instancia
(recupera n=4 de la pila) retorna 6*4=24
Valor de retorno ĺ 24
Aunque la función i es un buen ejemplo para demostrar cómo funciona una
función recursiva, la recursividad no es un buen modo de resolver esta función,
que sería más sencilla y rápida con un simple bucle .
#include <iostream>
using namespace ÷;
/* Prototipo de función */
void Permutaciones(char *, int l=0);
Permutaciones(palabra);
();
return 0;
}
0 1 2 3 4
A B C D /0
1 2 3 4
# B C D /0
$ 2 3 4
# % C D /0
Ahora sólo quedan dos elementos permutables, así que imprimimos ésta
permutación, e intercambiamos los elementos: l y l+i+1, es decir el 2 y el 3.
$ 2 3 4
# % D C /0
$ 2 3 4
# % /0 C D
En el caso particular de que l+i+1 sea justo el número de elementos hay que
mover hacia la izquierda los elementos desde la posición l+1 a la posición l:
$ 2 3 4
# % C D /0
1 2 3 4
# B C D /0
1 2 3 4
# C B D /0
$ 2 3 4
# & B D /0
$ 2 3 4
# & D B /0
Y así sucesivamente.
'
^
Existen otras formas de implementar algoritmos recursivos, no es necesario que
una función se invoque a si misma.
Este mismo mecanismo se puede implementar con tres, cuatro o con cualquier
número de funciones.
#include <iostream>
double par(int);
double impar(int);
double suma(int);
int () {
double suma(int n) {
if(n % 2) return impar(n);
else return par(n);
}
double par(int n) {
return impar(n-1)-1/double(n);
}
double impar(int n) {
if(n == 1) return 1;
return par(n-1)+1/double(n);
}
((
^
Torres de Hanói
ejercicio de fibonacci
http://codepad.org/m3v0fWLz
(c
2010-11-11 00:58:55
/*
* Copypaste(p) by b0ch0n
*/
#include <iostream>
bool pasada=false;
int main()
Palindromo(\"alguna\");
Palindromo(\"salas\");
Palindromo(\"anitAlaValaTina\");
Palindromo(\"cualquiera\");
Palindromo(\"zq\");
Palindromo(\"xx\");
Palindromo(\"dabalearrozalazorraelabad\");
system(\"pause\");
char cadAux[40]=\"\";
bool palindromo=true;
char primerChar;
char ultimoChar;
if(!pasada)
primerChar=tolower(*pPrimero);
ultimoChar=tolower(*pUltimo);
if(primerChar==ultimoChar)
if(n>0)
pasada=true;
palindromo=true;
return Palindromo(cadAux);
else
if(largo>1)
palindromo=false;
if(palindromo)
cout<<\", es palindromo\"<<endl<<endl;
else
cout<<\", no es palindromo\"<<endl<<endl;
pasada=false;
return;