Llamada recursiva de funciones en lenguaje c (problema de la torre de Hanoi, problema de recursividad de escaleras, etc.)

Llamada recursiva de funciones en lenguaje c (problema de Hanoi, problema recursivo de escalera, etc.)

Cuando entré por primera vez en contacto con el lenguaje C, sentí que la función de llamada recursiva aquí era bastante complicada y difícil de entender. Ahora, con el propósito de revisar, aclararé e introduciré algunos temas recursivos.

1. ¿Qué es una llamada recursiva?

La llamada recursiva de una función se refiere a llamar directa o indirectamente a la función misma en el proceso de llamar a una función.

2. Análisis clave

El punto clave es analizar la relación recursiva entre las primeras n-1 veces y el enésimo proceso de un determinado problema a resolver; además, la condición de inicio de la recursividad no debe ignorarse y debe escribirse por separado.

3. Ejemplos

3.1 Hallar recursivamente n!

Análisis: n! = N * (n-1) !; (n-1)! = (N-1) * (n-2)! …… Cuando n = 1, n! = 1.

Código de función:

int jiecheng(int n)
{
	if(n==1)
		return 1;
	else
		return(n*jiecheng(n-1));
}

3.2 Problema de la torre de Hanoi (Hanoi)

Análisis: Comprender cómo mover las primeras n-1 veces y la última, cuando n = 1, este caso especial debe considerarse por separado.

Tomando n = 64 como ejemplo, los pasos de resolución de problemas considerados deberían ser: supongamos que hay un maestro que puede mover las primeras 63 capas de A a B (el orden de grande primero, pequeño primero) y no importa cómo se mueva, lo que tenemos que hacer es mover la última capa de A a C, y luego mover las 63 capas de B a C, completando así el último paso.

Recursividad hacia adelante: Este maestro mueve las primeras 63 capas de A a B, y de B a C, también se utiliza el método anterior, como se muestra en la figura siguiente,

finalmente recursivo an = 1.

Cuando n = 1, simplemente cambie esta capa de A-> C.

Código de función:

void hanoi(int n, char A, char B, char C)  //实现n层塔从A借助B移动到C。
{
    void move(char a, char b);
    if(n==1)
        move(A, C);
    else
    {
        hanoi(n-1, A, C, B); //前n-1层从A借助C移动到B
        move(A, C);          //第n层从A移到C
        hanoi(n-1, B, A, C); //移动到B的n-1层借助A移动到C
    }
}
void move(char a, char b)    //定义打印函数
{
    printf("%c->%c\n",a,b);
}

Código completo:

#include<stdio.h>
#include<stdlib.h>
int main()
{
    void hanoi(int n, char A, char B, char C);
    char A='A', B='B', C='C';
    int n;
    scanf("%d",&n);
    printf("%d层汉诺塔移动步骤为：\n",n);
    hanoi(n, A, B, C);
    return 0;
}
void hanoi(int n, char A, char B, char C)  //实现n层塔从A借助B移动到C。
{
    void move(char a, char b);
    if(n==1)
        move(A, C);
    else
    {
        hanoi(n-1, A, C, B); //前n-1层从A借助C移动到B
        move(A, C);          //第n层从A移到C
        hanoi(n-1, B, A, C); //移动到B的n-1层借助A移动到C
    }
}
void move(char a, char b)    //定义打印函数
{
    printf("%c->%c\n",a,b);
}

Resultados de la operación (n = 3 como ejemplo, porque n = 64 pasos son demasiados):

3.3 Problema recurrente de subir escaleras

Las escaleras tienen n escalones. Puedes subir las escaleras un escalón, dos escalones o tres escalones. ¿Cuántas formas diferentes hay de calcular?

Análisis: La atención se centra en el último paso. Hay tres formas de avanzar en el último paso, a saber: paso 1, paso 2 y paso 3. Suponiendo que el último paso es hasta el nivel 1, continúe considerando los primeros n-1 pasos (aplique recursividad), y finalmente todos los pasos son lad (n-1) + lad (n-2) + lad (n-3 ).

Código de función:

int lad(int n)       //定义函数
{
	if(n==1)
		return 1;
	else if(n==2)
		return 2;
	else if(n==3)
		return 4;
	else
		return lad(n-1)+lad(n-2)+lad(n-3);  //
}

Código completo:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int lad(int n);
    int n;
    scanf("%d",&n);
    printf("%d",lad(n));
    return 0;
}
int lad(int n)
{
	if(n==1)
		return 1;
	else if(n==2)
		return 2;
	else if(n==3)
		return 4;
	else
		return lad(n-1)+lad(n-2)+lad(n-3);
}

resultado de la operación:

4. Resumen

La clave de la recursividad es comenzar con la cola, encontrar la relación entre el último paso y los n-1 pasos anteriores y enumerar las condiciones del valor inicial.