ПАСКАЛЬ: РЕКУРСИВНІ ОЗНАЧЕННЯ ТА ПІДПРОГРАМИ
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); мінімальними елементами є всі можливі сталі, і між собою вони непорівнювані.
Задачі
1.
Дати рекурсивне означення функції, що задає:
а)* суму значень цифр десяткового подання натурального n
;
б) n
-е число Фібоначчі;
в) найбільший спільний дільник двох натуральних;
г) обчислення із точністю e (див. приклад 4.4).
2.
* Дати нерекурсивне означення "91-функції Мак-Карті" F
, означеної так: F
(n
)=n
-10 при n
>100, F
(n
)=F
(F
(n
+11)) при n
£
100. Написати функцію обчислення F
(n
) при n
<200.
3.
* Розбиттям натурального числа n
називається спосіб його подання у вигляді суми натуральних чисел. Наприклад, розбиттями числа 4 є 4, 3+1, 2+2, 2+1+1, 1+1+1+1. Означити рекурсивно функцію Q
(n
), що задає кількість розбиттів натурального n
.
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.n | f.f | |||
| 2 | ? | ||||
| обчислення n=1: false
|
2 | ? | |||
| початок f := n*f(1) | 2 | ? | |||
| виклик f(1) | 2 | ? | f.f.n | f.f.f | |
| 2 | ? | 1 | ? | ||
| обчислення n=1: true
|
2 | ? | 1 | ? | |
| f := 1 | 2 | ? | 1 | 1 | |
| повернення з виклику f(1) | 2 | ? | |||
| закінчення f := n*f(1) | 2 | 2 | |||
Приклад 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<n
<m
, породжує два вкладені виклики. У результаті відбуваються повторні обчислення тих самих величин. Наприклад, виконання виклику з аргументами (5,2) веде до того, що виклик із аргументами (3,1) виконується двічі, з аргументами (2,1), (1,0) та (1,1) – по тричі, а загальна кількість вкладених викликів сягає 18.
Неважко збагнути, що чим більше m
і чим ближче n
до m
/2, тим більшою буде загальна кількість вкладених викликів. Ми не будемо
=m
div
2 або n
=m
div
2+1 вона більше, ніж 2m
/2
. Наприклад, за m
=60 це 230
, або приблизно 109
. Якщо навіть припустити, що за секунду можна виконати 106
викликів, то треба більше 1000 секунд, тобто приблизно 20 хвилин. Проте неважко написати рекурсивну функцію, виклик якої з аргументом m
породжує не більше, ніж m
/2 вкладених викликів (задача 9.7).
Отже, вживання рекурсивних підпрограм вимагає обережності та вміння оцінити можливу глибину рекурсії та загальну кількість викликів. Не завжди слід писати рекурсивні підпрограми безпосередньо за рекурсивним означенням. Принаймні, для обчислення біноміальних коефіцієнтів узагалі краще скористатися циклом (розділ 5.2). Справа в тім, що виконання кожного виклику підпрограми потребує додаткових дій комп'ютера, описаних у розділі 8. Тому "циклічний" варіант описання обчислень виконується, як правило, швидше від рекурсивного. Також не слід уживати рекурсію для обчислення елементів рекурентних послідовностей. За великої глибини рекурсії це взагалі може призвести до вичерпання автоматичної пам'яті та аварійного завершення програми.
У цьому розділі ми розглядаємо лише так звану пряму рекурсію
, коли підпрограма містить виклики самої себе. У програмуванні зустрічається також і непряма рекурсія
, коли підпрограма містить виклики інших підпрограм, а ті – виклики цієї підпрограми. Приклади непрямої рекурсії та реалізацію її в мові Паскаль ми розглянемо в розділі 21.
Задачі
4.
* Виразити словами залежнiсть значення, що повертається функцією
function
sumdi ( n : integer ) : integer;
begin
if
n < 10 then
sumdi := n
else
sumdi := n mod
10 + sumdi ( n div
10 )
end,
від значення параметра. Вважається, що аргумент у її виклику невід'ємний.
5.
* Написати процедуру друкування десяткових цифр цілого
а) у зворотному порядку, починаючи з молодших розрядів;
б) у звичайному порядку, починаючи зі старших розрядів.
6.
Написати функцію обчислення за m, n,
де 0£n
£ m
,біноміального коефіцієнта C
(m
,n
) згідно з палимо, що C
(m
,n
)=1 при n
=0 або n
=m
; у противному разі
а) C
( m
, n
) = C
( m
-1, n
-1 ) m
/ n
;
б) C
( m
, n
) = C
( m
, n
-1 ) ( m-n
+1 ) / n
;
в) C
( m
, n
) = C
( m
, n
+1 ) ( n
+1 ) / ( m-n
).
Підрахувати в кожному варіанті загальну кількість виконань викликiв функції при обчисленні коефіцієнта за m
=6, n
=2 та за m
=8, n
=5.
7.
* Написати варіант функції обчислення C
(m
,n
), при виконанні якого завжди відбувається не більше, ніж m
/2 рекурсивних викликів.
8.
Проімітувати звернення до функції Gcd (приклад 9.8) з аргументами
а)15 і 25; б) 13 і 21; в) 1024 і 729.
10.
* Для довiльного n
>0 указати числа an
та bn
такi, що при обчисленнi НСД(an
,bn
) за допомогою функції Gcd з прикладу 9.8 загальна кiлькiсть виконань викликiв дорiвнює n
.
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
.
Основна мета цього алгоритму – скоротити кількість множень при піднесенні до степеня. Наприклад, за цим алгоритмом x
5
=x
×
(x
2
)2
, тобто достатньо три множення замість чотирьох: x
×
x
×
x
×
x
×
x
. Одне множення економиться за рахунок того, що x
2
зберігається як проміжне значення і множитися само на себе. Так само x
10
=1× (x
5
)2
=(x
5
)2
, що вимагає лише чотирьох множень (три з них для обчислення x
5
) замість дев'яти "лобових". Але тут доведеться зберігати спочатку x
2
, а потім x
5
.
Як бачимо, обчислення xn
зводиться до обчислення xn
div
2
, запам'ятання його, піднесення до квадрату, та множення його на 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
не може бути більше, ніж log2
n
. Отже, глибина рекурсії виклику з аргументом n
не перевищує log2
n
.
Таку глибину можна вважати доброю властивістю алгоритму. При кожному виконанні виклику відбувається не більше одного ділення, піднесення до квадрату та множення, тому загальна кількість арифметичних операцій не більше 3log2
n
. За великих значень n
це суттєво менше "лобових" n
-1 множень. Наприклад, за n
=1000 це приблизно 30.
Зауважимо, що при деяких значеннях n
наведений алгоритм не дає найменшої кількості множень, необхідних для обчислення n
-го степеня. Наприклад, при n
=15 за цим алгоритмом необхідні 6 множень, хоча можна за допомогою 3-х множень обчислити x
5
, після чого помножити його на себе двічі (разом 5 множень). Проте написати алгоритм, який задає обчислення довільного степеня з мінімальною кількістю множень, – не зовсім проста задача. Залишимо її для наполегливих читачів.
Побудуємо нерекурсивний аналог наведеного алгоритму. Подамо обчислення за рекурсивним алгоритмом у такому вигляді:
x
13
= (x
6
)2
´
x
1
= ((x
3
)2
´
x
0
)2
´
x
1
= (((x
1
)2
´
x
1
)2
´
x
0
)2
´
x
1
Цьому відповідає така обробка показників степенів, що обчислюються:
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 по степенях двійки відповідає такому поданню x
13
: x
23
´
x
22
´
1´x
20
.
Отже, достатньо обчислювати степені
x
20
=x
, x
21
=x
2
, x
22
=(x
2
)2
, x
23
=(x
22
)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;
Задача
11.
Імітувати виконання виклику функції pow (обидва варіанти) з аргументами x
=2, n
=11. Указати загальну кількість виконуваних арифметичних операцій при n
= 5, 10, 15, 16, 1000, 1023, 1024.