Рекурсивні означення та підпрограми

1. Рекурсивні означення

Був собі білий бичок. І пішов він у ліс…

З усної народної творчості

Часто кажуть, що рекурсивне означення – це коли щось означається з його ж допомогою. Фраза ця не зовсім точна, а вірніше, зовсім неточна. Кожне означення задає щось, і цим чимось є, як правило, об'єкти, що утворюють деяку множину.

Означення називається рекурсивним, якщо воно задає елементи множини за допомогою інших елементів цієї ж множини. Об'єкти, задані рекурсивним означенням, також називаються рекурсивними. Нарешті, рекурсія – це використання рекурсивних означень.

Приклади

1. Значення функції "факторіал" задаються виразом: 0!=1, n!=n (n-1)!. Вони утворюють множину {1,2,6,…}: 0!=1, 1!=1, 2!=2, 3!=6, … . Усі її елементи, крім першого, означаються рекурсивно.

Отже, функція "факторіал" задається рекурентним співвідношенням порядку 1 і початковим відрізком 0!=1. Узагалі, будь-яке рекурентне співвідношення порядку k разом із завданням перших k елементів послідовності являє приклад рекурсивного означення.

2. Арифметичні вирази зі сталими та знаком операції '+' у повному дужковому записі (ПДЗ) задаються таким означенням:

1) стала є виразом у ПДЗ;

2) якщо E і F є виразами у ПДЗ, то (E)+(F) також є виразом у ПДЗ.

Такими виразами є, наприклад, 1, 2, (1)+(2), ((1)+(2))+(1). Всі вони, крім сталих, означаються рекурсивно.

Об'єкти, означені в прикладах 9.1–9.2, тобто значення функції "факторіал" та дужкові записи виразів, є рекурсивними.

У рекурсивних означеннях не повинно бути "зачарованих кіл", коли об'єкт означається за допомогою себе самого або за допомогою інших, але означених через нього ж.

Приклади

3. Змінимо означення функції "факторіал" на таке: n!=n (n-1)! за n>0, 0!=1!. Спочатку значення функції від 1 виражається через її ж значення від 0, яке, у свою чергу, – через значення від 1. За цим "означенням" так і не дізнатися, чому ж дорівнює 1!.

4. "У попа був собака, піп його любив, той з'їв шматок м'яса, піп його забив, і в землю закопав, і на камені написав, що у попа …" і так далі. Ця сумна історія не має кінця, і не можна сказати, що ж саме піп написав на камені.

5. "– Де ти гроші береш?

– У шухлядці.

– А там вони звідки?

– Дружина кладе.

– А в неї звідки?

– Я даю.

– А де ти береш?

– У шухлядці…"

У цьому старому анекдоті не називається справжнє джерело грошей. Якщо через A, B, C позначити чоловіка, його дружину та шухлядку, то пересування грошей зображається так: A C B A …, і справжнє джерело грошей залишається невідомим.

Щоб подібна "дурна нескінченність" не виникала в рекурсивному означенні, повинні виконуватися умови:

1.множина означуваних об'єктів є частково упорядкованою;

2.кожна спадна за цим упорядкуванням послідовність елементів закінчується деяким мінімальним елементом;

3.мінімальні елементи означаються нерекурсивно;

4.немінімальні елементи означаються за допомогою менших від них елементів.

Неважко переконатися, що означення з прикладів 9.1–9.2 задовольняють ці умови, а з прикладів 9.3–9.5 – ні.

Для тих, кому не знайомі терміни "частково упорядкована множина" та "мінімальний елемент", дамо невелике пояснення.

Будь-яка множина пар, складених з елементів деякої множини, називається відношенням на цій множині. Наприклад, множина пар {(1,1), (1,2), (2,1)} на множині {1, 2}.

Відношення називається відношенням часткового порядку, якщо воно має такі властивості:

1.для кожного елемента a множини пара (a, a) є у відношенні;

2.якщо у відношенні є пара (a, b) з різними елементами a і b, то пари (b, a) там немає. При цьому ми кажемо, що a менше b. У множині можуть бути й непорівнювані елементи, що один з одним пару не утворюють;

3.якщо a менше b, а b менше c, то a менше c. Втім, елементів a, b, c таких, що a менше b, а b менше c, у множині може й не бути – при виконанні властивостей (1) і (2) відношення буде відношенням часткового порядку.

Множина з заданим на ньому відношенням часткового порядку називається частково упорядкованою. Елемент частково упорядкованої множини називається мінімальним, якщо в множині немає елементів, менших його.

Очевидно, що в прикладі 9.1 кожні два елементи множини {1, 2, 6, …} порівнювані між собою, а мінімальним є 1. У прикладі 9.2 ідентифікатор менше іншого, якщо той утворюється з нього дописуванням символів наприкінці. Так, a менше a1 і aaa, а a1 і aa непорівнюванні. Ідентифікатор a – мінімальний. У прикладі 9.3 один вираз менше іншого, якщо він є його частиною. Так, 1 і 2 менше, ніж (1)+(2), а (1)+(2) менше, ніж ((1)+(2))+(1); мінімальними елементами є всі можливі сталі, і між собою вони непорівнювані.

2. Рекурсивні підпрограмиЗа правилами мови Паскаль щодо області дії означень, тіло підпрограми може мiстити виклики підпрограм, чиї заголовки записані вище в тексті програми. Звідси випливає, що підпрограма може містити виклики самої себе – рекурсивні виклики. Виконання такого виклику нічим не відрізняється від виконання виклику будь-якої іншої підпрограми. Підпрограма з рекурсивними викликами називається рекурсивною.

Приклад 6. Напишемо рекурсивну функцію f за таким означенням функції "факторіал": n!=n (n-1)! за n>1, 1!=1 (вважається, що n>0).

function f ( n : integer ) : integer;

begin

if n = 1 then f := 1

else f := n * f ( n-1 )

end; 

При імітації виконання викликів рекурсивних підпрограм їх локальні змінні позначають у такий спосіб. Якщо підпрограма F викликана з програми, то її локальна змінна X позначається F.X. За виконання кожного рекурсивного виклику підпрограми F, указаного в її тiлi, з'являється нова змiнна X. Вона позначається дописуванням префікса "F." до позначення змінної X у попередньому виклику: F.F.X, F.F.F.X тощо.

Приклад 7. Імітацію виконання виклику f(2) функції з прикладу 9.6 можна податі таблицею:

що виконуєтьсястан пам'яті

Виклик f(2)f.nf.f

2?

обчислення n=1: false2?

початок f := n*f(1)2?

виклик f(1)2?f.f.nf.f.f

2?1?

обчислення n=1: true2?1?

f := 12?11

повернення з виклику f(1)2?

закінчення f := n*f(1)22



Приклад 8. Найбільший спiльний дільник НСД(a,b) натуральних a і b можна обчислити рекурсивно на основі таких рівностей:

якщо b = 0, то НСД(a, b) = a,

якщо a mod b = 0, то НСД(a, b) = b,

якщо a mod b > 0, то НСД(a, b) = НСД( b, a mod b ).

Цьому означенню відповідає така рекурсивна функція обчислення НСД:

function GCD ( a, b : integer) : integer;

{ Greatest Common Divisor – Найбільший Спiльний Дільник}

begin

if b=0 then GCD:=a else

if a mod b=0 then GCD := b

else GCD := GCD ( b, a mod b)

end;



З рекурсивними підпрограмами пов'язано два важливих поняття – глибина рекурсії та загальна кількість викликів, породжених викликом рекурсивної підпрограми.

Розглянемо перше з них. У прикладі 9.6 наведено функцію обчислення n!. Очевидно, що її виклик із аргументом, наприклад, 4, закінчується лише після закінчення виклику з аргументом 3, а той, у свою чергу, після виклику з аргументом 2 тощо. Такі виклики називаються вкладеними. Отже, виклик із аргументом 4 породжує ще три вкладені виклики.

Взагалі, за виклику з аргументом n породжується ще n-1 виклик, і загальна кількість незакінчених викликів досягає n. Отже, максимальна кількість незакінчених рекурсивних викликів при виконанні виклику підпрограми називається глибиною рекурсії цього виклику.

За виконання виклику з глибиною рекурсії m одночасно "існують" m екземплярів локальної пам'яті. Кожний екземпляр має певний розмір, і якщо глибина буде надто великою, то автоматичної пам'яті, яку надано процесу виконання програми, може не вистачити.

Друге поняття можна назвати загальною кількістю вкладених викликів, породжених викликом рекурсивної підпрограми. Ця кількість значною мірою впливає на час виконання виклику. Проілюструємо це наступним прикладом.

Приклад 9. За властивостями трикутника Паскаля, біноміальний коефіцієнт C(m,n)=1 при m 1 або n=0 або n=m; у противному разі

C(m,n)=C(m-1,n-1)+C(m-1,n).

Згідно цього означення напишемо рекурсивну функцію обчислення за m, n, де 0 n m, біноміального коефіцієнта C(m,n):

function C(m, n : integer) : integer;

begin

if (m<=1) or (n=0) or (n=m) then C:=1

else C:= C(m-1, n-1)+C(m-1, n)

end;

Як бачимо, кожний виклик, у якому значення аргументів m>1, 0
Неважко збагнути, що чим більше m і чим ближче n до m/2, тим більшою буде загальна кількість вкладених викликів. Ми не будемо точно означати її залежність від аргументів. Скажемо лише, що за n=mdiv2 або n=mdiv2+1 вона більше, ніж 2m/2. Наприклад, за m=60 це 230, або приблизно 109. Якщо навіть припустити, що за секунду можна виконати 106 викликів, то треба більше 1000 секунд, тобто приблизно 20 хвилин. Проте неважко написати рекурсивну функцію, виклик якої з аргументом m породжує не більше, ніж m/2 вкладених викликів (задача 9.7).Отже, вживання рекурсивних підпрограм вимагає обережності та вміння оцінити можливу глибину рекурсії та загальну кількість викликів. Не завжди слід писати рекурсивні підпрограми безпосередньо за рекурсивним означенням. Принаймні, для обчислення біноміальних коефіцієнтів узагалі краще скористатися циклом (розділ 5.2). Справа в тім, що виконання кожного виклику підпрограми потребує додаткових дій комп'ютера, описаних у розділі 8. Тому "циклічний" варіант описання обчислень виконується, як правило, швидше від рекурсивного. Також не слід уживати рекурсію для обчислення елементів рекурентних послідовностей. За великої глибини рекурсії це взагалі може призвести до вичерпання автоматичної пам'яті та аварійного завершення програми.

У цьому розділі ми розглядаємо лише так звану пряму рекурсію, коли підпрограма містить виклики самої себе. У програмуванні зустрічається також і непряма рекурсія, коли підпрограма містить виклики інших підпрограм, а ті – виклики цієї підпрограми. Приклади непрямої рекурсії та реалізацію її в мові Паскаль ми розглянемо в розділі 21.

3. "Ханойські вежі"

На дошці є три голки: 1, 2, 3. На голці 1 розміщена вежа з n дисків; нижній диск має найбільший діаметр, а діаметр кожного наступного менший від попереднього. За один хід із будь-якої голки можна взяти верхній диск і перемістити на іншу, але дозволено класти диск лише на дошку або на диск більшого діаметра. Треба перемістити усю вежу з голки 1 на голку 3.

Ця гра називається "Ханойські вежі", оскільки за легендою з n=64 дисками її почали понад 1000 років тому ченці в одному монастирі поблизу Ханоя у В'єтнамі; коли вони закінчать її, настане кінець світу. Розв'язанням цієї гри-задачі є послідовність перенесень дисків. Написати програму друкування позначень цих перенесень.

Для перенесення вежі висотою n дисків з голки 1 на голку 3 необхідно перенести вежу висотою n-1 на голку 2, потім перенести нижній диск на голку 3 та перенести вежу з голки 2 на голку 3. При перенесенні вежі з 1 на 2 допоміжною є голка 3, а при перенесенні з 2 на 3 – голка 1. Інша послідовність дій неможлива. Отже, розв'язання задачі для вежі висотою n описується через розв'язання задачі для вежі висотою n-1.

Позначимо disk(a,b) перенесення одного диску з голки a на голку b, tow(h, a, b, c) – перенесення вежі висотою h з голки a на b з використанням голки c як допоміжної (tow – це скорочення від tower, або вежа). За h>1 виконання tow(h, a, b, c) зводиться до виконання

tow(h-1, a, c, b); disk(a, b); tow(h-1, c, b, a),

а за h=1 – до виконання

disk(a, b).

Отже, маємо програму:

program Hantow(input, output);

var n : integer;

procedure disk(f, t : integer);

begin writeln(f, '->', t) end;

procedure tow(h : integer; f, t, v : integer);

begin

if h=1 then disk(f, t) else

begin

tow(h-1, f, v, t); disk(f, t); tow(h-1, v, t, f)

end

end;

begin readln(n); tow(n, 1, 3, 2) end.

Очевидно, що глибина рекурсії викликів цієї процедури дорівнює значенню їх першого аргументу h.

Визначимо кількість переносів дисків як функцію f(n), де n – висота вежі. Очевидно, що f(1)=1, і що f(n)=2 f(n-1)+1. За принципом індукції неважко довести, що f(n)=2n-1. Значення f(64) дорівнює приблизно 1022. Якщо припустити, що кожної секунди ченці переносять один диск, то для переносу такої вежі потрібно приблизно 1015 років! Навіть якщо припустити, що комп'ютер здатний щосекунди друкувати по сто тисяч позначень переносів, то й тут знадобиться 1010 років. Кінець світу, мабуть, настане раніше…

4. "Індійський алгоритм" піднесення до степеня

Цей алгоритм обчислення натурального n-го (n>0) степеня цілого числа x виглядає зовсім просто:

за n=1 xn = x,

за n>1 xn = xn mod 2 (xn div 2)2.

Основна мета цього алгоритму – скоротити кількість множень при піднесенні до степеня. Наприклад, за цим алгоритмом x5=x (x2)2, тобто достатньо три множення замість чотирьох: x x x x x. Одне множення економиться за рахунок того, що x2 зберігається як проміжне значення і множитися само на себе. Так само x10=1 (x5)2=(x5)2, що вимагає лише чотирьох множень (три з них для обчислення x5) замість дев'яти "лобових". Але тут доведеться зберігати спочатку x2, а потім x5.

Як бачимо, обчислення xn зводиться до обчислення xndiv2, запам'ятання його, піднесення до квадрату, та множення його на x за непарного n. Отже, обчислення xn описується рекурсивною функцією

function pow(x, n : integer) : integer;

var t : integer;

begin

if odd(n) then t:=x

else t:=1;

if n=1 then pow:=x

else pow:=t*sqr(pow(x, n div 2))

end;

Як бачимо, проміжні множники зберігаються в локальній пам'яті процесів виконання викликів функції, а саме в тих змінних, що ставляться у відповідність її імені.Тепер спробуємо описати залежність глибини рекурсії викликів функції від значення аргументу. У кожному наступному вкладеному виклику значення аргументу n менше від попереднього значення принаймні вдвічі. Оскільки за n=1 відбувається повернення з виклику, то таких зменшень значення аргументу n не може бути більше, ніж log2n. Отже, глибина рекурсії виклику з аргументом n не перевищує log2n.

Таку глибину можна вважати доброю властивістю алгоритму. При кожному виконанні виклику відбувається не більше одного ділення, піднесення до квадрату та множення, тому загальна кількість арифметичних операцій не більше 3log2n. За великих значень n це суттєво менше "лобових" n-1 множень. Наприклад, за n=1000 це приблизно 30.

Зауважимо, що при деяких значеннях n наведений алгоритм не дає найменшої кількості множень, необхідних для обчислення n-го степеня. Наприклад, при n=15 за цим алгоритмом необхідні 6 множень, хоча можна за допомогою 3-х множень обчислити x5, після чого помножити його на себе двічі (разом 5 множень). Проте написати алгоритм, який задає обчислення довільного степеня з мінімальною кількістю множень, – не зовсім проста задача. Залишимо її для наполегливих читачів.

Побудуємо нерекурсивний аналог наведеного алгоритму. Подамо обчислення за рекурсивним алгоритмом у такому вигляді:

x13 = (x6)2 x1 = ((x3)2 x0)2 x1 = (((x1)2 x1)2 x0)2 x1

Цьому відповідає така обробка показників степенів, що обчислюються:

13 = 6 2+1 = (3 2+0) 2+1 = ((1 2+1) 2+0) 2+1.

Як бачимо, обчисленню степенів відповідає обчислення значення 13, поданого поліномом відносно 2. Коефіцієнтами його є цифри двійкового розкладу числа 13. Неважко переконатися, що обчисленню степеня з довільним показником n так само відповідає обчислення n, представленого двійковим розкладом. Причому цей розклад-поліном записано за схемою Горнера. Розкриємо дужки в ньому:

1 23+1 22+0 21+1 20.

Коефіцієнти при 20, 21, 22 тощо – це послідовні остачі від ділення на 2 чисел

n, n div 2, (n div 2) div 2 тощо,

причому остачі 1 відповідає в рекурсивному алгоритмі присвоювання t:=x, а 0 – присвоювання t:=1. Таким чином, двійковий розклад, наприклад, числа 13 по степенях двійки відповідає такому поданню x13: x23 x22 1 x20.

Отже, достатньо обчислювати степені

x20=x, x21=x2, x22=(x2)2, x23=(x22)2 тощо

та відповідні їм остачі від ділення на 2 показників

n, n div 2, (n div 2) div 2, ((n div 2) div 2) div 2 тощо,

накопичуючи в добутку лише ті двійкові степені, які відповідають остачам 1. У наступному алгоритмі добуток степенів накопичується в змінній t, а двійкові степені – в змінній x:

function pow(x, n : integer) : integer;

var t : integer; notfin : boolean;

begin

t:=1; notfin:=true;

while notfin do

begin

if odd(n) then t:=t*x;

n:=n div 2;

if n>0 then x:=x*x else notfin:=false

end;

pow:=t

end;