Una\u00a0funci\u00f3n es recursiva cuando se define en funci\u00f3n de si misma, pero no todas la funciones pueden llamarse a si mismas. Deben estar dise\u00f1adas especialmente para que sean recursivas, de otro modo podr\u00edan conducir a bucles infinitos, o a que el programa termine inadecuadamente.<\/p>\n
C++ permite la recursividad. Cada vez que se llama a una funci\u00f3n, se crea un juego de variables locales, de este modo, si la funci\u00f3n hace una llamada a si misma, se guardan sus variables y par\u00e1metros, usando la pila, y la nueva instancia de la funci\u00f3n trabajar\u00e1 con su propia copia de las variables locales. Cuando esta segunda instancia de la funci\u00f3n retorna, recupera las variables y los par\u00e1metros de la pila y continua la ejecuci\u00f3n en el punto en que hab\u00eda sido llamada.<\/p>\n
Por ejemplo:<\/p>\n
Prodr\u00edamos crear una funci\u00f3n recursiva para calcular el factorial de un n\u00famero entero.<\/p>\n
El factorial se simboliza como n!, se lee como “n factorial”, y la definici\u00f3n es<\/em>:<\/p>\n #e3e3e3;”>n! = n * (n-1) * (n-2) * … * 1<\/span><\/p>\n Para este ejemplo no es posible calcular el factorial de n\u00fameros negativos, no est\u00e1 definido.<\/p>\n Debemos de tomar en cuenta que el factorial de cero es 1. De modo que una funci\u00f3n bien hecha para c\u00e1lculo de factoriales deber\u00eda incluir un control para esos casos:<\/p>\n La recursividad consume muchos recursos de memoria y tiempo de ejecuci\u00f3n, y se debe aplicar a funciones que realmente le saquen partido.<\/p>\n Tambi\u00e9n existen otras formas de implementar algoritmos recursivos, por lo que no es necesario que una funci\u00f3n se invoque a si misma.<\/p>\n Ejemplo:\u00a0un par de funciones A y B pueden crear un algoritmo recursivo si la funci\u00f3n A invoca a la funci\u00f3n B, y esta a su vez invoca a la funci\u00f3n A.<\/p>\n Veamos un ejemplo. Partamos de la siguiente serie:<\/p>\n Aqui tenemos otro ejemplo aun mas complejo:<\/p>\n #include<\/a> using namespace std;<\/em><\/p>\n double par(int);<\/em><\/p>\n double impar(int);<\/em><\/p>\n double suma(int);<\/em><\/p>\n int main() {<\/em><\/p>\n \u00a0 \u00a0 cout <\/em><\/p>\n \u00a0 \u00a0 cout <\/em><\/p>\n \u00a0 \u00a0 cout <\/em><\/p>\n \u00a0 \u00a0 cout <\/em><\/p>\n \u00a0 \u00a0 cout <\/em><\/p>\n \u00a0 \u00a0 cout <\/em><\/p>\n \u00a0 \u00a0 return 0;<\/em><\/p>\n }<\/em><\/p>\n double suma(int n) {<\/em><\/p>\n \u00a0 \u00a0 if(n % 2) return impar(n);<\/em><\/p>\n \u00a0 \u00a0 else return par(n);<\/em><\/p>\n }<\/em><\/p>\n double par(int n) {<\/em><\/p>\n \u00a0 \u00a0 return impar(n-1)-1\/double(n);<\/em><\/p>\n }<\/em><\/p>\n double impar(int n) {<\/em><\/p>\n \u00a0 \u00a0 if(n == 1) return 1;<\/em><\/p>\n \u00a0 \u00a0 return par(n-1)+1\/double(n);<\/em><\/p>\n }<\/em><\/p>\n \u00a0<\/p>\n Referencias:\u00a0<\/a>http:\/ #Mastery<\/a>21 #TC<\/a>1017<\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":" Una función es recursiva cuando se define en función de si misma, pero no todas la funciones pueden llamarse a si mismas. Deben estar diseñadas especialmente para que sean recursivas, de otro modo podrían conducir a bucles infinitos, o a que el programa termine inadecuadamente.<\/p>\n 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.<\/p>\n Por ejemplo:<\/p>\n Prodríamos crear una función recursiva para calcular el factorial de un número entero.<\/p>\n El factorial se simboliza como n!, se lee como “n factorial”, y la definición es<\/em>:<\/p>\n #e3e3e3;”>n! = n * (n-1) * (n-2) * … * 1<\/span><\/p>\n Para este ejemplo no es posible calcular el factorial de números negativos, no está definido.<\/p>\n Debemos de tomar en cuenta que el factorial de cero es 1. De modo que una función bien hecha para cálculo de factoriales debería incluir un control para esos casos:<\/p>\n La recursividad consume muchos recursos de memoria y tiempo de ejecución, y se debe aplicar a funciones que realmente le saquen partido.<\/p>\n También existen otras formas de implementar algoritmos recursivos, por lo que no es necesario que una función se invoque a si misma.<\/p>\n Ejemplo: un par de funciones A y B pueden crear un algoritmo recursivo si la función A invoca a la función B, y esta a su vez invoca a la función A.<\/p>\n Veamos un ejemplo. Partamos de la siguiente serie:<\/p>\n Aqui tenemos otro ejemplo aun mas complejo:<\/p>\n #include<\/a> <\/em><\/p>\n using namespace std;<\/em><\/p>\n double par(int);<\/em><\/p>\n double impar(int);<\/em><\/p>\n double suma(int);<\/em><\/p>\n int main() {<\/em><\/p>\n cout <\/em><\/p>\n cout <\/em><\/p>\n cout <\/em><\/p>\n cout <\/em><\/p>\n cout <\/em><\/p>\n cout <\/em><\/p>\n return 0;<\/em><\/p>\n }<\/em><\/p>\n double suma(int n) {<\/em><\/p>\n if(n % 2) return impar(n);<\/em><\/p>\n else return par(n);<\/em><\/p>\n }<\/em><\/p>\n double par(int n) {<\/em><\/p>\n return impar(n-1)-1\/double(n);<\/em><\/p>\n }<\/em><\/p>\n double impar(int n) {<\/em><\/p>\n if(n == 1) return 1;<\/em><\/p>\n return par(n-1)+1\/double(n);<\/em><\/p>\n }<\/em><\/p>\n <\/p>\n Referencias: <\/a>http:\/\/c.conclase.net\/curso\/?cap=024<\/a><\/p>\n#e3e3e3;\">\/* Funci\u00f3n recursiva para c\u00e1lculo de factoriales *\/\n#aa4400; font-weight: bold;\">int<\/span> factorial(#aa4400; font-weight: bold;\">int<\/span> n) {\n #aa4400; font-weight: bold;\">if<\/span>(n #aa4400; font-weight: bold;\">return 0;\n #aa4400; font-weight: bold;\">else<\/span> #aa4400; font-weight: bold;\">if<\/span>(n > 1) #aa4400; font-weight: bold;\">return<\/span> n*factorial(n-1); \/* Recursividad *\/\n #aa4400; font-weight: bold;\">return<\/span> 1; \/* Condici\u00f3n de terminaci\u00f3n, n == 1 *\/\n}<\/pre>\n#e3e3e3;\">1 - 1\/2 + 1\/3 - 1\/4 + 1\/5 - ... - 1\/2*n + 1\/2*n+1 - ...<\/pre>\n
Recursividad <\/h2>\n
#e3e3e3;\">\/* Función recursiva para cálculo de factoriales *\/\n#aa4400; font-weight: bold;\">int<\/span> factorial(#aa4400; font-weight: bold;\">int<\/span> n) {\n #aa4400; font-weight: bold;\">if<\/span>(n #aa4400; font-weight: bold;\">return 0;\n #aa4400; font-weight: bold;\">else<\/span> #aa4400; font-weight: bold;\">if<\/span>(n > 1) #aa4400; font-weight: bold;\">return<\/span> n*factorial(n-1); \/* Recursividad *\/\n #aa4400; font-weight: bold;\">return<\/span> 1; \/* Condición de terminación, n == 1 *\/\n}<\/pre>\n#e3e3e3;\">1 - 1\/2 + 1\/3 - 1\/4 + 1\/5 - ... - 1\/2*n + 1\/2*n+1 - ...<\/pre>\n