Рекурсивное обучение итераций и функций

Первоначальное понимание модульных программ

В реальной программе пользовательская функция вызывается даром, и в нее также включается соответствующий файл заголовка, а также интерфейс определения функции. Так была создана простая функция сложения.
Объявление функции

#ifndef __ADD_H__
#define __ADD_H__

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

#endif

Я помещаю этот оператор в файл, каталог которого - add.h, где

#ifndef __ADD_H__
#define __ADD_H__

#endif

Цель состоит в том, чтобы предотвратить непрерывную передачу раздела определения всей функции, когда функция постоянно вызывается, что приводит к слишком большому объему кода основной программы. Принцип вызова функции заключается в том, что код из каталога определения функции перемещается в место, где он должен использоваться, через файл заголовка, а затем выполняется.
Определение функции

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

Поместите его в каталог, где находится каталог add.c, и поместите функцию соответствующей функции в каталог со значением подсказки, которое может лучше взаимодействовать с другими и быть читаемым.
Основная функция

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

    return 0;
}

При цитировании файла заголовка пользовательской функции используйте двойные кавычки "".

Самая простая рекурсия

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

Это неограниченная рекурсия. Программа остановится через некоторое время, и появится всплывающее окно с предупреждением. Причина в том, что во время работы программы локальные переменные, сгенерированные во время выполнения, будут сохранены в области памяти, называемой стеком. Ограничений нет. Рекурсия, продолжайте вызывать себя, продолжайте печатать «ха-ха», она заполнит стек.
И эта программа тоже понятна.Рекурсия - это вызов функции самой себе.С помощью современных модных словечек в Интернете она широко известна как матрешка.

Разработайте рекурсивную функцию для вывода 1 2 3 4 из 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;
}

Первый раз, когда вы хотите использовать рекурсию для реализации определенной функции, на самом деле очень невежественно, даже если учитель закончил, программа набрана, а отладка настраивается шаг за шагом, наблюдая, как код идет строка за строкой, особенно Это вызов функции. На последнем уровне, когда условия вызова не выполняются, окно запуска программы будет распечатывать символы один за другим. Я не понимал этого на ранней стадии. Как программа выполняется слой за слоем. Когда я вернулся, я просто забыл, где выполнялась программа.После того, как учитель нарисовал картинку и объяснил ее, я понял, что шаг за шагом входил, а шаг за шагом выходил. Когда последний уровень больше не соответствует условиям и выполнение завершено, всплывающее окно завершается, а после всплывающего окна на предыдущий уровень продолжается выполнение следующего оператора и так далее.

Не создавайте временные переменные, найдите длину строки

Во-первых, напишите функцию, которая может определять длину строки независимо от рекурсии,
самым простым, конечно же, является прямое использование библиотечной функции для вычисления длины строки.

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

Затем используйте настраиваемую функцию

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

Вся строка не может быть вызвана функцией напрямую. Вы можете использовать только адрес строки в качестве переменной-указателя, чтобы указать на первый символ строки. Вызов входит в функцию. После каждого использования нажимайте +1, пока не увидите '\ 0 ', вычисление длины строки прекращается. Счетчик используется как счетчик для записи длины строки. Но нам нужна функция, которая не использует временные переменные для достижения этой функции.

#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;
}

Рекурсия остается прежней. Ее легче понять, нарисовав диаграмму. Визуализируйте процесс выполнения программы и улучшите понимание. Существуют определенные ограничения, и каждый уровень вызывающих функций приближает их к невыполнению оператора if. Остановите рекурсивный процесс. Обычно известные как стоп-куклы.

Рекурсия и итерация для поиска факториала

Поняв предыдущие два рекурсивных примера, я также независимо написал этот рекурсивный код для поиска факториала. Общая идея состоит в том, чтобы запросить n! , Сначала попросите (n-1)! , Хочу попросить (n-1)! , Сначала попросите (n-2)! , Перенесемся вперед, чтобы попросить 2! , Просто сначала найдите 1! , Так что он все еще вызывает себя непрерывно, код выглядит следующим образом:

#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;
}

Который также использовал цикл for для написания другой функции для достижения цели.

Найдите n-ю последовательность Фибоначчи

Последовательность Фибоначчи, 1 1 2 3 5 8 ... Проще говоря, если вы хотите знать n-е, вам нужно знать n-1-е и n-2-е, и вы должны знать n-1-ю сумму Для n-2-го вы должны знать n-2 и n-3-е, n-3 и n-4 ... и так далее, но чтобы найти n-е рекурсивно, количество требуемых операций равно 2 ^ n + 2 ^ (n-1) + ... + 2 ^ 2 + 2 операций. Когда он достигает 40-го или более, у программы уже есть очевидное ожидание. Вам нужно подождать, чтобы получить результат. Количество вычислений На самом деле он уже очень большой. Для каждого n + 1 количество операций увеличится вдвое, а время операции - вдвое. Код такой:

#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;
}

Таким образом, в приведенном выше коде есть еще одна функция, которая реализуется путем итерации без рекурсии. Вы можете увидеть разницу во времени между двумя функциями для достижения цели при ее запуске. Поэтому, когда количество вызовов функций в рекурсии слишком велико, объем вычислений огромен. , Необходимо использовать другие средства для достижения цели.