Aprendizaje recursivo de iteraciones y funciones.

Comprensión inicial de programas modulares

En un programa real, la función personalizada no se llama por nada y también se incluye el archivo de encabezado correspondiente, así como la interfaz de definición de función. Entonces se creó una función de suma simple.
Declaración de función

#ifndef __ADD_H__
#define __ADD_H__

//函数的声明
int Add(int x, int y);

#endif

Pongo esta declaración en el archivo cuyo directorio es add.h, donde

#ifndef __ADD_H__
#define __ADD_H__

#endif

El propósito es evitar que la sección de definición de toda la función se lleve continuamente cuando la función se llama continuamente, lo que hace que la cantidad de código del programa principal sea demasiado grande. El principio de la llamada de función es que el código en el directorio de definición de función se mueve al lugar donde debe usarse a través del archivo de encabezado y luego se ejecuta.
Definición de función

int Add(int x, int y)
{
    return (x + y);
}

Colóquelo en el directorio donde el directorio es add.c, y coloque la función de la función correspondiente en el directorio con el significado del mensaje, que puede cooperar mejor con otros y es legible.
Función principal

#include <stdio.h>
#include "add.h"
int main()
{
    int a = 15;
    int b = 25;
    printf("sum=%d\n",Add(a, b));

    return 0;
}

Cuando cite el archivo de encabezado de una función personalizada, utilice comillas dobles "".

La recursividad más simple

#include <stdio.h>
int main()
{
    printf("haha\n");
    main();
    return 0;
}//递归常见的错误，栈溢出，stack overflow

Esta es una recursividad sin restricciones. El programa se detendrá después de ejecutarse por un tiempo y aparecerá una ventana de advertencia. La razón es que cuando el programa se está ejecutando, las variables locales generadas durante el tiempo de ejecución se almacenarán en un área de memoria llamada pila. No hay límite. La recursividad de, sigue llamándose a sí mismo, sigue imprimiendo "jaja", llenará la pila.
Y este programa también es comprensible. La recursividad es la llamada de una función a sí misma. Usando las palabras de moda actuales de Internet, se le conoce comúnmente como una muñeca de anidación.

Diseñe una función recursiva para imprimir 1 2 3 4 en 1234

void print(int n)
{
    if (n > 9)
    {
        print(n / 10);
    }
    printf("%d ", n % 10);

}
#include <stdio.h>
int main()
{
    int num = 0;
    scanf("%d", &num);
    print(num);
    return 0;
}

La primera vez que desea usar la recursividad para implementar una determinada función es en realidad muy despistada, a pesar de que el profesor ha terminado, el programa está escrito y la depuración se ajusta paso a paso, viendo el código ir línea por línea, especialmente Es la llamada en la función. En el último nivel, cuando no se cumplen las condiciones de la llamada, la ventana en ejecución del programa imprimirá los caracteres uno por uno. No lo entendí en la etapa inicial. Cómo se ejecuta el programa capa por capa. Cuando volví, simplemente me olvidé de dónde se ejecutó el programa. Después de que el maestro hizo un dibujo y lo explicó, entendí que entraba un paso a la vez y que salía un paso a la vez. Cuando la última capa ya no cumple la condición y se completa la ejecución, se ejecuta la ventana emergente y, una vez que se alcanza la ventana emergente, se continúa ejecutando la siguiente instrucción, y así sucesivamente.

No cree variables temporales, encuentre la longitud de la cadena

Primero, escriba una función que pueda darse cuenta de la longitud de la cadena, independientemente de la recursividad,
lo más simple por supuesto es usar directamente la función de biblioteca para calcular la longitud de la cadena

#include <string.h>
int main()
{
        strlen();
}

A continuación, use una función personalizada

int my_strlen(char* str)
{
    int count = 0;
    while (*str != '\0')
    {
        count++;
        str = str + 1;
    }
    return count;
}

La función no puede llamar directamente a la cadena completa. Solo puede usar la dirección de la cadena como una variable de puntero para señalar el primer carácter de la cadena. La llamada ingresa a la función. Después de cada uso, haga +1 hasta que vea '\ 0 'de carácter, el cálculo de la longitud de la cadena se detiene. Count se utiliza como un recuento para registrar la longitud de la cadena. Pero lo que necesitamos es una función que no use variables temporales para lograr esta función.

#include <stdio.h>
int my_strlen(char* str)
{
    if (*str != '\0')
        return 1+my_strlen(str + 1);
    else
        return 0;
}//未使用临时变量进行计数，实现了求字符串长度
int main()
{
    char arr[] = "bit";
    int len = my_strlen(arr);//传送过去的是数组第一个元素的地址，并不是整个数组
    printf("len = %d\n", len);
    return 0;
}

La recursividad sigue siendo la misma. Es más fácil de entender dibujando un diagrama. Visualice el proceso de ejecución del programa y mejore la comprensión. Existen ciertas restricciones, y cada capa de funciones de llamada hace que las restricciones estén más cerca de no satisfacer la declaración if. Detén el proceso recursivo. Comúnmente conocidos como muñecos de parada.

Recursión e iteración para encontrar factorial

Después de comprender los dos ejemplos recursivos anteriores, también escribí de forma independiente este código recursivo para encontrar factorial. ¡La idea general es pedir n! ¡Primero pregunte por (n-1)! , ¡Quiere pedir (n-1)! ¡Primero pregunte por (n-2)! , ¡Avance rápido para querer pedir 2! , ¡Encuentra 1 primero! , Por lo que todavía se llama a sí mismo continuamente, el código es el siguiente:

#include <stdio.h>
int Fac1(int n)
{
    int num = 1;
    int i = 0;
    for (i = 1; i <= n; i++)
    {
        num = i * num;
    }
    return num;
}
int Fac2(int n)
{
    int ret = 1;
    if (n != 0)
         ret = n * Fac2(n - 1);
    else
        return ret;
}
int main()
{
    int n = 0;
    scanf("%d", &n);
    printf("%d!=%d\n",n, Fac1(n));
    printf("%d!=%d\n",n, Fac2(n));
    return 0;
}

Que también usó un bucle for para escribir otra función para lograr el propósito.

Encuentra la enésima secuencia de Fibonacci

Secuencia de Fibonacci, 1 1 2 3 5 8 ... En pocas palabras, si quieres saber el n-ésimo, tienes que saber el n-1o y el n-2o, y debes conocer la n-1a suma Para el n-2, debes conocer el n-2 y el n-3, el n-3 y el n-4 ... y así sucesivamente, pero para encontrar el n de forma recursiva, el número de operaciones necesarias es 2 ^ n + 2 ^ (n-1) + ... + 2 ^ 2 + 2 operaciones. Cuando llega al 40 o más, el programa ya tiene una espera obvia. Necesita esperar para obtener el resultado. El número de cálculos De hecho, ya es muy grande. Por cada n + 1, el número de operaciones aumentará dos veces y el tiempo de operación aumentará dos veces. El código es el siguiente:

#include <stdio.h>
int Fib1(int n)
{
    if (n <= 2)
        return 1;
    else
        return  Fib1(n - 1) + Fib1(n - 2);
}
int Fib2(int n)
{
    int a = 1, b = 1, c=0;
    int i = 0;
    if (n > 2)
    {
        for (i = 3; i <= n; i++)
        {
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }
    else
        return 1;
}
int main()
{
    int n = 0;
    scanf("%d", &n);
    int f2 = Fib2(n);
    printf("第%d个斐波那契数列：%d\n", n, f2);
    int f1 = Fib1(n);
    printf("第%d个斐波那契数列：%d\n", n, f1);
    return 0;
}

Entonces, hay otra función en el código anterior, que se implementa mediante iteración sin recursividad. Puede ver la diferencia de tiempo entre las dos funciones para lograr el objetivo cuando la ejecuta. Por lo tanto, cuando el número de llamadas a funciones en la recursividad es demasiado grande, la cantidad de cálculo es enorme , Es necesario utilizar otros medios para lograr el objetivo.