[ Миронченко ] Императивное и объектно-ориентированное програмирование на Turbo Pascal и Delphi

141

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

Лично я считаю, что и высокоспециализированные языки программирования ждет та же участь. Но в процессе их развития будут выработаны многие приемы, которые облегчат создание и увеличат возможности универсальных языков. Совершенно очевидно, что постепенно языки программирования еще больше приблизятся к естественному языку, а значит и циклы и рекурсия должны оставаться, так как многие задачи человек решает, комбинируя оба метода. Например, когда я выхожу на стадион, чтобы побегать, то часто ставлю задачу рекурсивно: пробегу-ка я половину намеченной дистанции, а там уже и до конца недалеко. А во время бега считаю круги, т.е. действую итеративно.

8.9. Быстрая сортировка

Худшее время работы алгоритма быстрой сортировки cn2 , как и у сортировки пузырем, выбором и вставками. Это означает, что можно придумать такие массивы, которые быстрая сортировка может упорядочить лишь за cn2 операций. Однако в среднем этот алгоритм работает очень быстро – даже быстрее, чем алгоритм сортировки слиянием, который всегда работает за время cn log2 n .

Алгоритм быстрой сортировки заключается в следующем:

Выбираем любое число из массива (обычно берут средний элемент, хотя можно выбирать элемент случайным образом), и переформировываем массив на две части так, чтобы в одной части стояли все элементы, меньшие этого числа, а во второй – большие. Затем к каждой части применяем алгоритм быстрой сортировки.

Разбивать массив на 2 части, в одной из которых находятся элементы большие заданного числа х, а в другой – меньшие его, мы умеем (см. главу «Массивы», пример № 6) – для этого мы искали первый элемент с начала массива, больший х и первый элемент с конца массива, меньший х. После этого мы переставляли эти элементы местами и начинали искать следующую пару элементов. Когда станет ясно, что переставлять больше нечего, алгоритм закончит работу.

Теперь давайте продемонстрируем, как будет работать быстрая сортировка для следующего массива:

Средний элемент – это M[5]=2.

После применения алгоритма перестановки элемента, получим следующий массив:

Теперь применяем алгоритм быстрой сортировки по очереди к первой и второй частям массива.

В первой части центральный элемент – это M[3]=1. Во втором – M[7]=8. Первая часть массива после перестановки элементов примет вид

Теперь надо отсортировать две части этого куска массива и т.д.

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

142

Пример 6: Быстрая сортировка.

1 : uses Crt,Dos;

2 : const

3 : n=34000;

4 : type

5 : Mas=array [1..n] of byte;

6 : var

7 : A:Mas;

8 : i:longint;

9 : Uhr,Min,Sek,mSek:word;{часы, минуты, секунды, миллисек.} 10: Uhr2,Min2,Sek2,mSek2:word;

11:

12:procedure BlaseSort(var M:array of byte);

13:var

14:i,j:longint;

15:tmp:integer; {Вспомогательная переменная}

16:begin

17:for j:=High(M)-1 downto 1 do

18:for i:=1 to j do

19:if M[i]>M[i+1] then

20:begin

21:tmp:=M[i+1];

22:M[i+1]:=M[i];

23:M[i]:=tmp;

24:end;

25:end;

26:

27:procedure SchnSort (var A:array of byte;L,R:longint);

28:var

29:B,Tmp:integer;

30:i,j:word;

31:begin

32:B:=A[(L+R) div 2];

33:i:=L;

34:j:=R;

35:while i<=j do{Делим массив на 2 части}

36:begin

37:while A[i]<B do

38:i:=i+1;

39:while A[j]>B do

40:j:=j-1;

41:if i<=j then

42:begin

43:Tmp:=A[i];

44:A[i]:=a[j];

45:A[j]:=Tmp;

46:i:=i+1;

47:j:=j-1;

48:end;

49:end;

50:if L<j then SchnSort(A,L,j); {Cортируем}

51:if i<R then SchnSort (A,i,R); {обе части}

145

40:begin

41:for j:=1 to n do {печатаем элементы массива А}

42:write(A[C[j]],' ');

43:writeln;

44:exit;

45:end;

46:B[i]:=1;{i-й элемент массива вошел в перестановку}

47:{формируем следующий элемент перестановки}

48:Umstellungen(A,B,C,ind+1);

49:B[i]:=0;{Освобождаем i-й элемент}

50:end;

51:end;

52:

53:begin

54:Clrscr;

55:randomize;

56:RandMass(A,100);{Строим числовой массив}

57:write('Mas A = ');

58:SchreibMass(A);

59:writeln;

60:Umstellungen(A,B,C,1);

61:readkey;

62:end.

8.11. Переборные алгоритмы

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

Мы с вами рассмотрим классическую задачу: найти все расстановки n ферзей на доске n n , при которых ни один из ферзей не может побить другого.

Очевидно, что для n = 1, 2,3 таких расстановок не существует. Для n = 4 задача

имеет 2 решения.

Давайте для удобства горизонтали и вертикали нумеровать числами. Тогда задача

соответствует координате некоторого ферзя.

Решение задачи сводится к одной рекурсивной функции StellNeueY. Она принимает в качестве параметров массив – 2-ю строку подстановки и номер столбца ind, на который надо поставить следующего ферзя. Ее алгоритм прост: просматриваем все поля ind-того столбца (цикл на строке 24), и смотрим, есть ли в массиве хотя бы один ферзь, который может побить ферзя, стоящего на поле (ind j ) . Если такой ферзь

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

146

Пример 8: Задача о 8 ферзях.

1 : uses

2 : Crt;

3 : const

4 : n=12;{Размер доски}

5 : type

6 : MasY=array[1..n] of byte;

7 :

8 : procedure SchrMas(var M:MasY);{Вывод подстановки}

9 : var

10:i:integer;

11:begin

12:for i:=1 to n do

13:write(i, ' ');

14:writeln;

15:for i:=1 to n do

16:write(M[i],' ');

17:writeln;

18:end;

19:

20:procedure StellNeueY(var M:MasY;ind:byte);

21:var

22:j,k:byte;

23:begin

24:for j:=1 to n do{просматриваем все поля i-го столбца}

25:begin

26:for k:=1 to ind-1 do{Проверяем, можно ли поставить ферзя на

j-е поле}

27:if ((ind+j)=(k+M[k]))or((ind -j)=(k-M[k]))or(j=M[k]) then

28:begin

29:k:=ind;

30:break;

31:end;

32:if (k=ind) then{Если поставить нельзя}

34:else

35:begin

36:M[ind]:=j; {Ставим ферзя}

37:if (ind=n) then{Если уже заполнили всю доску}

38:begin

39:SchrMas(M);

40:writeln;

41:end

43:StellNeueY(M,ind+1);

44:end;

45:end;

46:end;

47:

48:var

49:M:MasY;

50:begin

148

А, но она, в свою очередь, также вызывает подпрограмму А, а значит А должна быть

10:function a(n:longint):longint;

11:begin

12:if (n=1) or (n=0) then

13:a:=1

14:else

15:if (n mod 2 =0) then

16:a:=2*f(n-1)

17:else

18:a:=3*f(n-3);

19:end;

20:

21:var

22:i:integer;

23:begin

24:Clrscr;

25:for i:=1 to 15 do

26:writeln(f(i));

27:end.

Вообще говоря, в этом примере можно обойтись и без косвенной рекурсии: просто подставить функцию a(n) в функцию f (n) , и свести решение задачи к обычной

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

Сразу хочется спросить: можно ли организовать косвенную рекурсию без слова forward?

149

Ответ: Да, можно. В следующем примере именно так и будет сделано.

Решать будем похожую задачу: будем вычислять f (a(n)) = a(n) + a([n / 2]) + a([n / 5]) , где a(n) - некоторая функция, вид которой заранее не известен, но известно то, что она может выражаться через саму функцию f (a(n)) .

Заметьте: в предыдущем примере функция f зависела от переменной n , а сейчас – от функции . Значит, нам придется орудовать с функциональным типом.

Пример 10: Косвенная рекурсия без forward.

1 : uses Crt;

2 : type

3 : Funk=function(n:longint;fun:Funk):longint;

4 :

5 : {Теперь мы передаем в функцию f не какую-то конкретную функцию, 6 : которую надо было описать выше, а ссылку на некоторую функцию} 7 : function f(n:longint;a:Funk):longint;

8 : begin

9 : f:=a(n,a)+a(n div 2,a)+a(n div 5,a); 10: end;

11:

12:{Так как а(n) тоже вызывает f, то ссылку придется передавать

13:и в саму функцию а, т.е. одним из параметров функции должна быть

14:ссылка на саму же функцию}

15:function a(n:longint;fun:funk):longint;far;

16:begin

17:if (n=1) or (n=0) then

18:a:=1

19:else

20:if (n mod 2 =0) then

21:a:=2*f(n-1,fun)

22:else

23:a:=3*f(n-3,fun);

24:end;

25:

26:var

27:i:integer;

28:begin

29:Clrscr;

30:for i:=1 to 15 do

31:writeln(f(i,a));

32:end.

Как видите, рекурсия без forward осуществима, причем мы решили более общую задачу, чем в предыдущем примере; но при этом пришлось перейти от функций к функционалам, что усложняет программный код, а также увеличивает количество параметров, которые надо передавать в функции. Естественно, теоретическая возможность обойтись без forward еще не означает, что пользоваться ею не стоит.

150

8.13. В чем итерация выигрывает у рекурсии

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

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

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

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

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

такая модификация рекурсии для них идеально подходит.

Возможность такой «модернизированной» рекурсии есть, например, в Prolog, где она называется хвостовой рекурсией.

8.14.Рекурсия в LISP

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

Например, алгоритм Евклида выглядит на LISP так:

Пример 11: Алгоритм Евклида на LISP.