¿Qué es la recursividad?

La recursión es una maravillosa herramienta de programación. Proporciona una manera simple y poderosa de abordar una variedad de problemas. Sin embargo, a menudo es difícil ver cómo se puede abordar un problema de forma recursiva; Puede ser difícil “pensar” recursivamente. También es fácil escribir un programa recursivo que demore demasiado en ejecutarse o que no finalice correctamente. En este artículo, repasaremos los conceptos básicos de la recursividad y, con suerte, lo ayudaremos a desarrollar o perfeccionar una habilidad de programación muy importante.

¿Qué es la recursión?

Para decir exactamente qué es la recursión, primero tenemos que responder “¿Qué es la recursividad?” Básicamente, se dice que una función es recursiva si se llama a sí misma. A continuación se muestra un pseudocódigo para una función recursiva que imprime la frase “Hello World” un total de veces de conteo :

función HelloWorld (cuenta) {
si (cuenta <1)
volver imprimir (“¡Hola Mundo!”);
HelloWorld (cuenta – 1);
}

Es posible que no esté claro de inmediato qué estamos haciendo aquí, así que sigamos con lo que sucede si llamamos a nuestra función con el recuento establecido en 10. Como el recuento no es menor que 1, no hacemos nada en la primera línea. En el siguiente, imprimimos “¡Hola Mundo!” una vez. En este punto, necesitamos imprimir nuestra frase 9 veces más. Como ahora tenemos una función HelloWorld que puede hacer exactamente eso, simplemente llamamos a HelloWorld (esta vez con el recuento establecido en 9) para imprimir las copias restantes. Esa copia de HelloWorld imprimirá la frase una vez, y luego llamará a otra copia de HelloWorld para imprimir el 8. restante. Esto continuará hasta que finalmente llamemos a HelloWorld con el recuento establecido en cero. HelloWorld (0) no hace nada; solo regresa. Una vez que HelloWorld (0) ha terminado, HelloWorld (1) también lo hace y vuelve. Esto continúa hasta nuestra llamada original de HelloWorld (10), que termina de ejecutarse después de imprimir un total de 10 “¡Hola Mundo!”.

Puede estar pensando que esto no es terriblemente emocionante, pero esta función demuestra algunas consideraciones clave al diseñar un algoritmo recursivo:

  1. Maneja un “caso base” simple sin usar recursividad.
    En este ejemplo, el caso base es “HelloWorld (0)”; si se le pide a la función que imprima cero veces, entonces regresa sin generar más “HelloWorld”.
  2. Evita los ciclos.
    Imagínese si “HelloWorld (10)” llama “HelloWorld (10)” que llama “HelloWorld (10)”. Terminaría con un ciclo infinito de llamadas, y esto generalmente resultaría en un error de “desbordamiento de pila” mientras se ejecuta. En muchos programas recursivos, puede evitar ciclos haciendo que cada llamada de función sea para un problema que de alguna manera es más pequeño o más simple que el problema original. En este caso, por ejemplo, el recuento será cada vez menor con cada llamada. A medida que el problema se vuelve más y más simple (en este caso, consideraremos “más simple” imprimir algo cero veces en lugar de imprimirlo 5 veces) eventualmente llegará al “caso base” y dejará de repetirse. Hay muchas maneras de evitar ciclos infinitos, pero asegurarse de que estamos lidiando con problemas progresivamente más pequeños o más simples es una buena regla general.
  3. Cada llamada de la función representa un manejo completo de la tarea dada.
    A veces, la recursión puede parecer mágica en la forma en que resuelve los grandes problemas. Sin embargo, no existe un almuerzo gratis. Cuando a nuestra función se le da un argumento de 10, imprimimos “¡Hola Mundo!” una vez y luego lo imprimimos 9 veces más. Podemos pasar una parte del trabajo a una llamada recursiva, pero la función original todavía tiene que dar cuenta de las 10 copias de alguna manera.

Consulte los escenarios de casos de uso en http://www.daqwest.com/quests/26….

1) Jerarquías, redes o gráficos

2) Múltiples decisiones relacionadas

3) Relaciones explícitas recursivas

Buena suerte !!!

¿Alguna vez has visto Inception? Es una película de Christopher Nolan protagonizada por Leonardo DiCaprio.

[1]

Si no has visto la película, deberías hacerlo, especialmente si estás en ingeniería de software porque te hace PENSAR.

¿Qué tiene que ver con la recursividad?

El concepto de la película es muy similar a la recursividad.

La recursión es simplemente una función que se llama a sí misma hasta que se cumple alguna condición.

¿Lo obtuviste? Yo tampoco. Entonces, hablemos de película.

DiCaprio, que interpreta a Cobb, es un ladrón bastante inusual que roba información confidencial de personas dormidas. Se mete en tu sueño y crea una realidad falsa en la que renuncias a la información. La siguiente es una representación de código de este acto, una función simple.

función sueño () {
// robar información
regreso;
}

La tarea habitual de Cobb, que es extraer datos de las personas, es fácil. Pero, ¿qué tal ‘plantar’ una idea en la mente de alguien para que piensen que crearon la idea? Este es un desafío serio y requiere profundizar cada vez más en los sueños. Sí, exactamente, un sueño dentro de un sueño. Y aquí es donde la recursión es similar a la película.

función sueño () {
if (jobIsDone) {
regreso;
} más {
sueño(); // llamándose a sí mismo
}
}


La próxima vez que alguien pregunte qué es la recursividad, diles que es un sueño dentro de un sueño y di ¡Unagi!

[2]

Notas al pie

[1] ¿Cuál es tu opinión sobre Inception (película de 2010)?

[2] Imagen en nocookie.net

Aquí hay un artículo que tengo en mi blog personal. Puedo compartir el enlace, pero no estoy tan seguro si esto rompe las reglas de publicación, así que estoy copiando y pegando.

¿Qué es la recursión? Por favor tengan paciencia conmigo

Este será un artículo breve y técnico, así que tengan paciencia con mi mal inglés y mi estilo de escritura. El idioma también es un medio de comunicación y, a veces, no logra transmitir la comprensión, por lo que voy a volcar el concepto en inglés simple lo mejor que pueda.

Simple pero confuso

La recursión es de hecho un tema confuso (especialmente para los estudiantes) aunque es simple. Los conceptos simples no son necesariamente fáciles de implementar porque depende en qué medida el concepto sigue directamente la forma natural de pensar. Creo que la razón principal por la cual la recursión es confusa es que no sigue una forma natural directa de pensar como el caso en la iteración. Proporcionaré un ejemplo para demostrar el concepto de recursión y espero que ayude a los lectores a dominar la habilidad de pensar de forma recursiva, pero antes de saltar al tema correctamente, definamos más o menos lo que significa una función desde una perspectiva de programación.

Una función es una función

En lenguajes de procedimiento como C o Pascal, el código fuente se compone de funciones o procedimientos. Por otro lado, los lenguajes orientados a objetos como C ++ tienen funciones (llamadas métodos) pero están incrustadas dentro de las definiciones de clase. Independientemente de los detalles de implementación (recursión, iteración, complejidad, rendimiento, etc.), una función no es más que un bloque de código que recibe cero o más parámetros y devuelve algún tipo de salida. Por ejemplo, la siguiente función recibe dos parámetros enteros A y B y devuelve la suma de los dos enteros.

int Sum (int A, int B)
{
devolver A + B;
}

Llamar a esta función es sencillo. Simplemente proporcione la entrada requerida y reciba la salida esperada. En el caso de las funciones recursivas, no es diferente, simplemente llame a una función con la entrada adecuada y reciba algo de salida esperada, lo que lo hace diferente y confuso.

Funciones recursivas

Se debe invocar una función recursiva por primera vez desde la definición de función externa, sin embargo, se sigue llamando desde la definición de función interna hasta que alcanza una condición de detención. Desde la perspectiva de la computadora, si una función se llama a sí misma o llama a otra función, sigue siendo una llamada de función regular siempre que invoque el nombre de función correcto y especifique los parámetros de entrada requeridos.

Divide y conquistaras

Sé que todavía no expliqué la parte confusa, ¿por qué incluso se molestaría en llamar a la función desde su definición en primer lugar? La recursión sigue una técnica de diseño de algoritmo bien conocida llamada divide y vencerás, que significa dividir un problema en subproblemas del mismo tipo o relacionados hasta que el subproblema sea lo suficientemente simple como para ser resuelto directamente. Las soluciones a los problemas secundarios se combinan para dar una solución al problema original. Entonces, ¿cómo divide y vencerás se relaciona con una función que se llama a sí misma? En la primera llamada a la función recursiva, proporciona la entrada a tamaño completo, en el momento en que la función comienza a invocarse, debe proporcionar una entrada de tamaño más pequeño, sigue proporcionando un tamaño más pequeño en cada llamada hasta que la entrada sea lo suficientemente simple como para resolverla. El paso final es combinar todas las soluciones en una única gran solución.

Ejemplo

Admito que todavía estoy hablando de manera abstracta. Las palabras aún están secas, así que intentemos entender la recursividad usando un ejemplo mientras pensamos en voz alta. El ejemplo factorial es excelente, pero creo que suena aburrido encontrar este ejemplo en cada artículo que habla sobre la recursividad. Voy a discutir un ejemplo que es más fácil de resolver usando la iteración, sin embargo, lo resolveremos usando la recursividad para mejorar nuestras habilidades para pensar de forma recursiva.
Considera este ejemplo. Dada una matriz de enteros, encuentre el número máximo en la matriz. Este problema se puede resolver de forma iterativa recorriendo la matriz elemento por elemento y comparando el elemento actual con el máximo actual mientras se actualiza el máximo siempre que el elemento actual sea más grande. Esta es la forma natural de pensar, usted asume que el primer elemento es el máximo y luego verifica cada elemento en la matriz para ver si es más grande o no. Pensar de forma recursiva no sigue una forma tan natural, pero es un poco diferente. ¿Aún recuerdas la técnica de dividir y conquistar? Si es así, eso es recurrencia de una forma u otra. Apliquemos divide y vencerás a este problema.
Una forma de hacerlo es dividir la matriz en dos mitades y luego encontrar el máximo de la primera mitad y luego el máximo de la segunda mitad y luego devolver el máximo más grande (ya que tenemos dos máximos). La primera llamada a la función recursiva opera en toda la matriz, luego las llamadas posteriores operan en mitades de la matriz y así sucesivamente hasta el punto en que operamos en un solo elemento. Considere la siguiente matriz de enteros

4, 3, 1, 7, 2, 8, 6, 10, 5, 9

Comenzamos con una matriz de 10 elementos, luego dos matrices de 5 elementos, luego 4 matrices de 2 o 3 elementos, luego 8 matrices de uno o dos elementos. Como puede ver una vez que la matriz se reduce a una matriz de uno o dos elementos, es muy fácil encontrar el número máximo. Si la matriz tiene solo un elemento, el máximo es el elemento mismo. Si la matriz consta de dos elementos, el máximo es el elemento más grande. Eche un vistazo a la figura a continuación comenzando desde la parte inferior de la rama izquierda del árbol:

7> 2, entonces se toma 7
7> 1, entonces se toma 7
4> 3, entonces se toma 4
7> 4, entonces se toma 7

Luego, desde la parte inferior de la rama derecha del árbol:

9> 5, entonces se toma 9
10> 9, entonces se toma 10
8> 6, entonces se toma 8
10> 8, entonces se toma 10

Y finalmente tomamos el máximo más grande de las ramas izquierda y derecha 10> 7, por lo que 10 es el elemento máximo en la matriz

Basándonos en el ejemplo anterior, intentemos caracterizar la anatomía general de una función recursiva.

  1. Necesitamos un caso base para la entrada para que la función deje de llamarse más allá de ese punto. En nuestro ejemplo, el caso base es cuando la matriz tiene solo un elemento en ese caso, solo devuelve el elemento en sí como máximo.
  2. El segundo problema al que debemos prestar atención es que la entrada o el tamaño del problema deben reducirse cada vez que la función se llama a sí misma. En nuestro ejemplo, comenzamos con una matriz completa y luego con media matriz hasta que proporcionamos una matriz que consta de un solo elemento. Si el tamaño de entrada no se reduce, no se alcanzará el caso base, lo que hace que la función recursiva desborde la memoria de la pila.
  3. Las soluciones deben combinarse para producir la solución final. En nuestro ejemplo, el máximo en el lado izquierdo del árbol de recursión fue 7, mientras que el máximo en el lado derecho del árbol de recursión fue 10. Comparamos esos dos números y devolvemos el más grande.

Apliquemos las reglas anteriores y salgamos con una función recursiva:

int max (int A [], int i, int j)
{
//Caso base
si (i == j)
{
devolver A [i];
}

// Calcular la posición del elemento medio
int m = (i + j) / 2;

// Llamando a la misma función con tamaño reducido
int left_max = max (A, i, m);
int right_max = max (A, m + 1, j);

// Combinando soluciones
if (left_max> right_max)
{
return left_max;
}
más
{
return right_max;
}
}

Como puede ver, acabamos de implementar las tres reglas mencionadas anteriormente. Tenga en cuenta lo siguiente:

  1. I y J representan índices de matriz inicial y final. La primera vez que llama a la función recursiva, proporciona I = 0 y J = longitud de la matriz
  2. Una vez que calcule la posición del elemento medio, entonces el índice de inicio I = 0 y J = m para la rama izquierda, mientras que I = m + 1 y J = longitud de la matriz para la rama derecha. Así es como reducimos el tamaño de entrada jugando con los valores de I y J
  3. Cuando I == J esto significa que estamos apuntando a un único elemento que es el caso base
  4. Una vez que se calculan los valores máximo izquierdo y derecho, combinamos las dos soluciones devolviendo la más grande.

Así que aquí está el trato. Si desea mejorar sus habilidades de recursividad, entonces necesita practicar más sobre esas reglas. Antes de finalizar este artículo, déjenme ser claro sobre lo siguiente

  1. La recursión no significa exactamente dividir y conquistar. Es al revés, dividir y conquistar es una técnica de diseño de algoritmos que utiliza la recursividad
  2. Divide y vencerás se puede usar para diseñar algoritmos rápidos, como la búsqueda binaria y la ordenación por fusión. En nuestro ejemplo, no mejoramos el rendimiento simplemente porque operamos en ambas ramas del árbol. Comparando esto con la búsqueda binaria, en cada llamada a la función recursiva operamos en una rama del árbol

Por lo tanto, tenga en cuenta que el objetivo principal de este artículo es comprender el concepto de recursión, no cómo diseñar algoritmos rápidos. Espero que este artículo sea útil, pero estoy seguro de que no hay nada como practicar

RECURSIÓN EN C

El proceso de llamar a una función por sí mismo se llama recursividad y la función que se llama a sí misma se llama función recursiva.

  • La recursión se usa para resolver varios problemas matemáticos dividiéndolos en problemas más pequeños.
  • Este método de resolver un problema se llama Divide and Conquer.
  • En programación, se usa para dividir problemas complejos en problemas más simples y resolverlos individualmente.

Sintaxis de la función recursiva

returnntype recursive_func ([lista de argumentos])
{
declaraciones;
… … …
recursive_func ([argumento real]);
… … …
}

  • Para evitar una llamada recursiva infinita, necesitamos definir una condición de salida adecuada en una función recursiva.

C PROGRAMA PARA MOSTRAR LA FUNCIÓN RECURSIVA INFINITA

#include
#include
int main ()
{
printf (“Hola mundo”);
principal();
devuelve 0;
}

Salida
Hola mundo Hola mundo Hola mundo Hola mundo Hola mundo Hola mundo Hola mundo
Hola mundo Hola mundo Hola mundo Hola mundo Hola mundo Hola mundo Hola mundo Hola
hola mundo hola mundo hola mundo hola mundo hola mundo hola mundo hola
mundoHola mundoHola mundoHola mundoHola mundoHola mundoHola mundoHola hola
ldHola mundoHola mundoHola mundoHola mundoHola mundoHola mundoHola mundoH
mundo de hola mundo de hola mundo de hola mundo de hola mundo de hola mundo de hola mundo de hola
o mundo Hola mundo Hola mundo Hola mundo Hola mundo Hola mundo Hola mundo Hola w
.
.
.
infinito

– En este programa, estamos llamando a main () desde main (), que es recursividad.
– Pero no hemos definido ninguna condición para que el programa salga.
– Por lo tanto, este código imprimirá “Hola mundo” infinitamente en la pantalla de salida.

Para más descarga de la aplicación gratuita de Android:

Lenguaje de programación C – Todo en uno – Aplicaciones en Google Play

Recomiendo encarecidamente Gödel, Escher, Bach: An Eternal Golden Braid de Douglas Hofstadter. Cubre la importancia de la recursividad en la conciencia, las matemáticas, la informática, el arte y la música. Cambió mi comprensión del Universo.

La recursión está estrechamente relacionada con la iteración y los sistemas autorreferenciales. Mi investigación principal es la matemática de la tetración o la exponenciación iterativa. Ver http://www.tetration.org . Hay dos formas válidas de representar un sistema dinámico en física, como PDE o como función iterada. Casi todos los sistemas caóticos y fractales son generados por funciones iterativas o recursivas. Pero incluso la física de todo el universo se supone que está representada por un operador de matriz que transforma el sistema de un instante a otro. La recursividad o iteración de este proceso permite que la dinámica del sistema se grafica con el tiempo. Entonces, se podría decir que en la mecánica cuántica, el estado del Universo a medida que cambia con el tiempo se puede determinar a través de la recursión, donde las leyes de la física están representadas por una función que transforma el Universo de un instante al siguiente,

Ver ¿Qué es la recursividad?

Así es como se ve una recursión:

Dejame explicar :

Una recursión es una función que se llama a sí misma hasta que se cumple una determinada condición. (O también pueden ser dos funciones que se llaman entre sí) Tomemos el ejemplo de factorial (15 factorial es el producto de todos los números naturales hasta 15 y está representado por [math] 15! [/ Math]), un ejemplo simple de recursivo función. ¡Así es como encontramos n !:

[matemáticas] n! = n (n-1)! [/ matemáticas]

¿Viste eso? Para definir [math] n! [/ Math], utilizamos factorial en sí. Ahora [math] (n-1)! [/ Math] se puede definir como:

[matemáticas] (n-1)! = (n-1) (n-2)! [/ matemáticas]

De esta manera, seguimos llamando factorial hasta que alcancemos [math] 0! [/ Math] al que le damos el valor 1. Esto se convierte en:

[matemáticas] n! = n (n-1) (n-2) (n-3)… (3) (2) (1) [/ matemáticas]

Ahora, impleméntelo en el código. Primero establecemos dos casos:

  • Caso base: esta es una condición que, cuando se satisface, detiene la recursividad. En nuestro caso, el caso base (o condición de salida) es que [math] 0! = 1 [/ math]
  • Caso recursivo: aquí es donde la función se llama a sí misma.

Intentemos escribirlo en Python:

Primero, definamos nuestro caso base. Aquí, nuestro caso base es [math] 0! = 1 [/ math] donde la función debería detenerse.

def factorial (n):
si n == 0:
volver 1

Ahora aquí está la parte recursiva:

def factorial (n):
si n == 0:
volver 1
más:
retorno n * factorial (n-1)

Esto es esencialmente lo mismo que habíamos hecho anteriormente. Llamará al factorial de los números hasta que llegue a 1 y los multiplicará a todos.

Sin embargo, si accidentalmente pierde el caso base, la recursión nunca se detendrá. Lo llamamos una recursión infinita y es algo como esto:

La secuencia de Fibonnaci también se puede hacer de forma recursiva. Puedes hacerlo como un desafío para ti mismo.

Tanto factorial como Fibonacci son lo que llamamos recursiones primitivas, lo que significa que también podemos hacerlas en bucles “for”. Sin embargo, hay algunas funciones que son completamente recursivas, es decir, debemos hacerlas recursivamente.

Happy Coding 🙂

Aquí hay un pequeño problema matemático: ¿cuál es el factorial de 8?

El factorial de [math] n [/ math] es el producto de cada número entero desde [math] n [/ math] hasta 1 (formalmente, se escribe como [math] n! [/ Math]). [matemáticas] 4! = 4 \ veces3 \ veces2 \ veces1 = 24 [/ matemáticas].

Si escribimos un programa para calcular el factorial de n, podría verse así:

función factorial (n)
let x = 1
para i = n a 1 paso -1 do
dejar x = x * i
volver x

Es decir, introduzca la n y cree un producto inicial ( x ) con el valor 1 (la identidad multiplicativa ), y luego establezca sucesivamente i en el siguiente número en la serie decreciente y establezca x en sí mismo multiplicado por el valor de i . (No podemos usar este programa para calcular el factorial de 0.)

Pero eso es más cálculo de lo que necesitamos hacer. Sabemos que el factorial de 0 es 1:

fn factorial 0 = 1

¡y también sabemos que para cualquier valor n, el factorial de n es [math] n \ times (n-1)! [/ math]:

fn factorial n = n * factorial (n-1)

Esta es la definición recursiva de la función factorial:

fn factorial 1 = 1
n = n * factorial (n-1)

Se define como un caso base (la primera línea) donde la función “toca fondo” y no se necesitan más cálculos, y un caso recursivo (la segunda línea), donde resolvemos el problema dando un solo paso hacia el caso base . El cálculo n * factorial(n-1) necesariamente, si se aplica una y otra vez, alcanzará el caso base si n fue mayor que 0 originalmente.

Esta función recursiva resuelve factorial (8) tomando

el producto de 8 y factorial (7), donde este último es

el producto de 7 y factorial (6), donde este último es

el producto de 6 y factorial (5), donde este último es

el producto de 5 y factorial (4), donde este último es

el producto de 4 y factorial (3), donde este último es

el producto de 3 y factorial (2), donde este último es

el producto de 2 y factorial (1), donde este último es

el producto de 1 y factorial (0), donde este último es

1

y el resultado final es, por supuesto, 40320.

Para comprender Recursion, debe comprender cómo funciona Stack, cómo almacenan los valores de la pila:

La recursión es una función que se llama a sí misma. Cada vez que una función se llama a sí misma, creando un ciclo, entonces eso es recursividad.

Le recomiendo que lea este artículo que explica desde cero cómo los valores de almacenamiento de la pila y los valores de retorno en términos de recursividad. Si desea más información sobre la recursividad, sugiero leer las primeras 100 páginas del libro SICP

No imprime el resultado en orden inverso a sus valores de retorno de la pila.

Tienes que entender dos cosas:

  • La pila funciona en el principal Last In first Out, por lo que Stack devuelve los valores que vienen en último lugar.
  • Hay dos tipos de recursión: recursión de la cabeza y recidiva de la cola

En la recursiva Head, la llamada recursiva primero encuentra su condición base y luego ejecuta el resto del código.

def head_recursion (x):
si x == 0:
regreso
más:
head_recursion (x-1)
print (“Recursión de la cabeza”, x)

head_recursion (3)

imprimirá:

Head Recursion 1
Head Recursion 2
Head Recursion 3

En la recursión de cola, Todo se ejecuta primero después de la función principal de llamada de recursión. Significa En la recursividad de cola La llamada recursiva es lo último en función.

def head_recursion (x):
si x == 0:
regreso
más:
print (“Recursión de la cabeza”, x)
head_recursion (x-1)

head_recursion (3)

imprimirá:

Head Recursion 3
Head Recursion 2
Head Recursion 1

La recursión es el proceso de dividir un gran problema en pequeños subproblemas (del mismo tipo) hasta llegar a un caso trivial , que se resuelve de inmediato.

El caso trivial se llama el “caso base” y generalmente es muy simple / obvio.

Considere el siguiente método:

Este es un método para calcular el factorial de un número (Ej 3 factorial = 3 * 2 * 1 = 6). En este caso, el caso base (trivial) es si el número es 0, el factorial de 0 se define como 1.

Si el número no es 0, entonces queremos devolver el número multiplicado por el factorial del número-1.

Por ejemplo, para 3 factorial, 3 factorial es 3 * 2 * 1, pero también podemos considerarlo como 3 * (factorial de 2), que es (3 * (2 * (factorial de 1))).

La recursión es un concepto complicado, pero solo recuerda que quieres hacer una pequeña cantidad de trabajo y luego hacer una llamada recursiva con un problema un poco más pequeño.

Para comprender la recursividad , primero debe comprender la recursividad .

Dejando de lado todos los chistes, la recursividad se define como dividir un problema en problemas más pequeños de la misma forma.

Por ejemplo:
[matemáticas] n! = n \ times (n-1)! [/ math]
podría expresarse como:
[matemáticas] 5! = 5 \ times4! [/ Math]
luego…
[matemáticas] 5! = 5 \ times4 \ times3! [/ Math]
y así sucesivamente … Probablemente pueda ver la naturaleza recursiva de los factoriales aquí.

En ciencias de la computación, la recursión se define mejor como una función que se llama a sí misma, por ejemplo, así es como puede verse una función recursiva usando C ++:

Hecho int (int n) {
si (n <= 1) {
retorno 1;
} más {
devuelve n * Hecho (n – 1);
}
}

Las muñecas rusas son una analogía útil para pensar en la recursividad:

Como otros han dicho, es un código autorreferencial, como una función que se llama a sí misma. Aquí está el ejemplo arquetípico, un programa factorial recursivo (esta versión simple solo asume que su argumento es un entero positivo):

doble factorial (doble n)
{
if (n <= 1) devuelve 1;
de lo contrario, devuelve n * factorial (n – 1);
}

Sin embargo, tenga en cuenta que la recurrencia innecesaria se considera una mala práctica de programación, el código resultante a menudo es ineficiente y también puede conducir a errores sutiles debido al agotamiento de la pila. Algunos compiladores optimizadores reconocen patrones de recursión simples y los eliminan; por ejemplo, un compilador puede convertir la función anterior en algo equivalente (más o menos) a lo siguiente:

doble factorial (doble n)
{
resultado = 1;
mientras que (n> 1) resultado * = n–;
resultado de retorno;
}

La recursión es un proceso que se llama a sí mismo para realizar una tarea determinada. Algunas de las características clave de la recursividad son:

  1. Simplemente mejora la legibilidad y, por lo general, no contribuye a la eficiencia a gran escala.
  2. El programa de recursión siempre consta de 2 partes; a. Caso base b. Proceso de caso.
  3. El caso del proceso conduce lentamente al caso base después de varias llamadas.

Entonces, ¿qué sucede exactamente en la recursividad?

El compilador crea múltiples clones del programa give y establece marcadores apropiados entre las llamadas a funciones para ejecutar el caso de prueba.

Considere el ejemplo factorial estándar:

hecho de hecho (int n)
{
si (n == 0)
retorno 1;
más
devuelve n * hecho (n-1);
}

Aquí el caso (n == 0) es el caso base. Y la condición más es el proceso.

Suponga que un programa de controlador ejecuta un programa de controlador que ejecuta un caso de prueba, hecho (5). El valor de n sobre múltiples llamadas disminuiría ND y llevaría al caso base y, por lo tanto, todos los procesos o clones convergen para dar una respuesta común.

Espero haber sido claro. 🙂

En pocas palabras, la recursividad es cuando la solución a un problema se basa en una versión más pequeña del mismo problema.

El ejemplo que se usa con frecuencia es factorial, que se define para enteros no negativos de la siguiente manera:

[matemáticas] n! = n \ times (n – 1)! [/ math]

[matemáticas] 0! = 1 [/ matemáticas]

Por ejemplo, [matemáticas] 5! = 5 \ veces 4 \ veces 3 \ veces 2 \ veces 1 = 120 [/ matemáticas]

A menudo, una solución programática de un problema recursivo es en sí misma recursiva, como esta función de Python para implementar factorial:

>>> hecho definido (n):
… si n == 0:
… volver 1
… más:
… Devuelve n * hecho (n – 1)

>>> hecho (5)
120

Definición de Wiki: la recursión es el proceso de repetir elementos de forma similar.

La recursión es básicamente un algoritmo a través del cual se rompe la tarea en muchas partes. La tarea que se rompe de esta manera debe ser una que consiste en hacer una cosa repetidamente. Por ejemplo

Desea agregar todos los números naturales hasta n, entonces el equivalente a la función ac sería como

int sum ( int n)

{

si (n == 0)

volver n;

más

devuelve n + suma (n-1); / * auto llamada a la función sum () * /

Ahora, lo que sucede realmente es que primero se recibe un número, que el número sea ‘n’. Luego se verifica si el número es cero o no, si no es cero, esta función se llama a sí misma con un número que es uno menos que el número recibido, es decir, ‘n-1’. Ahora, nuevamente, se verifica el número ‘n-1’ para determinar la condición de no ser cero y nuevamente esta función llamada se llama a sí misma con un número ‘n-2’ y la serie continúa hasta que el número recibido es 0.

Y luego la última función devuelve el valor 1 a la segunda última función que devuelve el valor 2 + 1 = 3 a la tercera y así sucesivamente. De esta manera, la serie continúa y obtenemos la suma hasta ‘n’.

Por lo tanto, después de ver un ejemplo, déjame decirte una cosa más, dividimos las funciones de recursión en dos subtareas principales,

1. El primero es identificar la tarea repetitiva que se realiza. Por ejemplo, en el programa anterior, lo que sucedió una y otra vez no fue más que suma.
2. Lo segundo es identificar la condición base que es cuándo terminará la tarea repetitiva.
Como tenía este problema, deberíamos saber cuándo finalizará la suma, la declaración del problema en sí misma le da la condición básica, cuando dice que debe calcular la suma de todos los números naturales hasta n, eso significa que no deseamos ir más allá de 0.

Espero que esto ayude.

int compute (int x) {
si (x <= 0)
volver x;
cálculo de retorno (x – 1);
}

Este es el ejemplo más simple que se me ocurre sin escribir un bucle infinito. La recursión es un método que se llama a sí mismo desde dentro de sí mismo, por lo general solo se recomienda si mejora la legibilidad o la eficiencia, y se recomienda su uso con precaución, ya que puede crear una gran cantidad de sobrecarga si la anidación se vuelve muy profunda y complicada.

La recursión en informática se ha cubierto en otras respuestas, pero nadie ha hablado aún sobre la teoría de la recursión en las matemáticas.

La Teoría de la recursividad, o Teoría de la computabilidad, es el estudio de funciones y conjuntos computables, a menudo observando si un conjunto dado es computable, o clasificando conjuntos en términos de su computabilidad o no computabilidad. Cuando digo computable me refiero efectivamente computable por algún algoritmo. Más precisamente, quiero decir que existe una Máquina de Turing que determina la pertenencia al conjunto, que, suponiendo la Tesis de Turing de la Iglesia, es lo mismo que tener un algoritmo efectivo.

Hay un muy buen artículo de Wikipedia sobre el tema, http://en.wikipedia.org/wiki/Com …, así que en lugar de darte las mismas cosas pero menos bien escrito, te sugiero que vayas y leas eso.

La partida Óleo-lienzo. 80 x 100 cms. 2007
http: //pacopomet.files.wordpress
paco pomet
Pintura (2000-2011)
http://pacopomet.wordpress.com/

Ver ¿Qué es la recursividad?

En un diccionario, encontré esta explicación:

Recursion – Ver Recursion
—————————————————–

En términos de informática, “recursión” es un proceso en el que una función se llama a sí misma, por un número finito de veces .

More Interesting

¿Cuáles son algunas formas interesantes de usar tecnologías no convencionales en la programación?

Si encuentro que las matemáticas discretas son totalmente comprensibles pero no realmente emocionantes, ¿debería reconsiderar estudiar CS? (Soy un estudiante de segundo año)

¿Cuáles son las variables de factor en el lenguaje R?

¿Por qué identificamos algoritmos que actúan en diferentes tamaños de entrada?

¿Cuáles son las fórmulas matemáticas para expresiones informáticas como: x = x / 5?

Un juego de 64 discos de Tower of Hanoi es jugado por un programa que realiza movimientos a una velocidad creciente. Comienza a 1000 movimientos por segundo. ¿Cuánto tiempo tomará?

¿Qué temas matemáticos recomiendas en informática?

Cómo mejorar mi forma analítica de pensar para trabajar matemáticamente para la programación de computadoras

¿Cuál es un ejemplo de un montón que requiere exactamente n * log (n) pasos? Sé que el límite superior de un montón es O (n log n), pero ¿cómo hago para mostrar un ejemplo donde requiera exactamente n * log (n) pasos?

¿El algoritmo de Bellman-Ford es pseudo polinomial?

¿Qué tan importante es que un lenguaje de programación sea Turing completo?

¿P = NP sería algo bueno?

¿En qué se diferencia la teoría lógica de las matemáticas de la teoría lógica de la informática?

¿Cuándo se llama función sobreyectiva a una función sobre?

¿Cuál es la correlación entre las matemáticas y la informática? ¿Por qué es necesario?