Рекурсивные функции

Рекурсивной (самовызываемой или самовызывающей) называют функцию, которая прямо или косвен­но вызывает сама себя.

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

Возможность прямого или косвенного вызова позволяет различать прямую или косвенную рекурсии. Функция называется косвенно рекурсивной в том случае, если она содержит обращение к другой функции, содержащей прямой или косвенный вызов первой функции. В этом случае по тексту определения функции ее рекурсивность (косвенная) может быть не видна. Если в функции используется вызов этой же функции, то имеет место прямая ре­курсия, т.е. функция по определению рекурсивная.

Рекурсивные алгоритмы эффективны в задачах, где рекурсия использована в самом определении обрабатываемых данных. Поэтому изучение рекурсивных методов нужно проводить, вводя динамические структуры данных с ре­курсивной структурой. Рассмотрим вначале только принципиальные возможности, которые предоставляет язык Си для организации рекурсивных алгоритмов.

В рекурсивных функциях необходимо выполнять следующие правила.

1. При каждом вызове в функцию передавать модифицированные данные.

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

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

Пример 1. Заданы два числа a и b, большее из них разделить на меньшее, используя рекурсию.

Текст программы может быть следующим:

. . .

double proc(double, double);

void main (void)

{

double a,b;

puts(“ Введи значения a, b : ”);

scanf(“%lf %lf”, &a, &b);

printf(“\n Результат деления : %lf”, proc(a,b));

}

//––––––––––––––––––– Функция –––––––––––––––––––––––

double proc( double a, double b) {

if ( a< b ) return proc ( b, a );

else return a/b;

}

Если a больше b, условие, поставленное в функции, не выполняется и функция proc возвращает нерекурсивный результат.

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

Пример 2. Функция для вычисления факториала неотрицательного значения k (для возможных отрицательных значений необходимо добавить дополнительные условия).

double fact (int k) {

if ( k < 1 ) return 1;

else

return k * fact ( k – 1);

}

Для нулевого значения параметра функция возвращает 1 (0! = 1), в противном случае вызывается та же функция с уменьшенным на 1 значени­ем параметра и результат умножается на текущее значение па­раметра. Тем самым для значения параметра k организуется вычисление произведения

k * (k–1) * (k–2) * ... * 3 * 2 * 1 * 1

Последнее значение «1» – результат выполнения условия k < 1 при k = 0, т.е. последовательность рекурсивных обращений к функции fact прекращается при вызове fact(0). Именно этот вызов приводит к последнему значению «1» в произведении, так как последнее выражение, из которого вызывается функция, имеет вид: 1 * fact( 1 – 1).

Пример 3. Рассмотрим функ­цию определения корня уравнения f(x) = 0 на отрезке [а, b] с заданной точностью eps. Предположим, что ис­ходные данные задаются без ошибок, т.е. eps > 0, f(a)*f(b) < 0, b > а, и вопрос о возможности существования нескольких кор­ней на отрезке [а,b] нас не интересует. Не очень эффективная рекурсивная функция для решения поставленной задачи приведена в следующей программе:

. . .

int counter = 0; // Счетчик обращений к тестовой функции

//–––––––– Нахождение корня методом деления отрезка пополам ––––––––––

double Root(double f(double), double a, double b, double eps) {

double fa = f(a), fb = f(b), c, fc;

if ( fa * fb > 0) {

printf("\n На интервале a,b НЕТ корня!");

exit(1);

}

с = (а + b) / 2.0;

fc = f(c);

if (fc == 0.0 || fabs(b – a) < = eps) return c;

return (fa * fс < 0.0) ? Root(f, a, c, eps) : Root(f, c, b, eps);

}

//–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––

void main()

{

double x, a=0.1, b=3.5, eps=5е–5;

double fun(double) ; // Прототип тестовой функции

x = Root (fun, a, b, eps) ;

printf ("\n Число обращений к функции = %d . ", counter);

printf ("\n Корень = %lf . ", x);

}

//–––––––––––––– Определение тестовой функции fun –––––––––––––––––

double fun (double x) {

counter++; // Счетчик обращений – глобальная переменная

return (2.0/x * соs(х/2.0));

}

Значения a, b и eps заданы постоянными только для тестового анализа полученных результатов, хотя лучше данные вводить с клавиатуры.

В результате выполнения программы с определенными в ней конкретными данными получим:

Число обращений к функции = 54 .

Корень = 3.141601.

Неэффективность предложенной программы связана, например, с излишним количеством обращений к программной реализации функции, для которой определяется корень. При каждом рекурсивном вызове функции Root повторно вычисляются значения f(a) и f(b), хотя они уже известны после предыдущего вызова.

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

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

При обработке динамических информационных структур, которые включают рекурсивность в само определение обрабатываемых данных, применение рекурсивных алгоритмов не имеет конкуренции со стороны итерационных методов.