/1, 2, 3/ И /4/ затем /1, 2/ и /3, 4/ и т.Д. }

^{uses crt;}

^{const N = 4;}

^type

^{TArr = array [1..N] of integer;}

^var

I, j, k, r, s: integer;

^{Flag1, Flag2: boolean; {Флаги - используются для управления выводом на экран}}

^{Block: TArr; { Block[I] - номер блока, содержащего элемент I}}

^{Next: TArr; {Next[I] - номер следующего блока для блока с номером I}}

^{Prev: TArr; {Prev[I] - номер предыдущего блока для блока с номером I}}

^{Forvd: array [1..N] of boolean; {Направление, в котором "движется" активный элемент I. При true – движение вправо, а при false - движение влево}}

^{procedure Output1; {Вывод разбиения}}

^begin

^{Flag1 := false;}

^{Write ('Разбиение ');}

^{for R := 1 to N do}

^begin

^{Flag2 := false;}

^{for I := 1 to N do}

^{if Block[I] = R then}

^begin

If not Flag2 then

^begin

^{Write ('{', I);}

^{Flag2 := true;}

^{Flag1 := true;}

^end

^else

^{Write (' ', I);}

^end;

If Flag1 then

^begin

^{Write ('} ');}

^{Flag1 := false;}

^end;

^end;

^Writeln;

^{end; {Output1}}

^{procedure Output2; {Вывод вспомогательных массивов и разбиения}}

^begin

^writeln;

^{Write ('Block: ');}

^{for R := 1 to N do}

^{Write (Block[R], ' ');}

^Writeln;

^{Write ('Next: ');}

^{for R := 1 to N do}

^{Write (Next[R], ' ');}

^Writeln;

^{Write ('Prev: ');}

^{for R := 1 to N do}

^{Write (Prev[R], ' ');}

^Writeln;

^{Write ('Forv: ');}

^{for R := 1 to N do}

^{Write (Forvd[R], ' ');}

^Writeln;

^Output1;

^{end; {Output2}}

^begin

^Clrscr;

^{for I := 1 to N do {Занесение I в первый блок}}

^begin

^{Block[I] := 1;}

^{Forvd[I] := true;}

^end;

^{Next[1] := 0;}

^{Вывод}

^Output1;

^{{ Output2; }}

^{J := N; {J - активный элемент}}

^{while J > 1 do}

^begin

^{K := Block[J];}

If Forvd[j] then { j движется вперед}

^begin

^{if Next [K] = 0 then {K -последний блок}}

^begin

^{Next[K] := J;}

^{Prev[J] := K;}

^{Next[J] := 0;}

^end;

^{if Next[K] > J then {J образует новый блок}}

^begin

^{Prev[J] := K;}

^{Next[J] := Next[K];}

^{Prev[Next[J]] := J;}

^{Next[K] := J;}

^end;

^{Block[J] := Next[K];}

^end

^{else {J движется назад}}

^begin

^{Block[J] := Prev[K];}

^{if K = J then {J образует одноэлементный блок}}

^{if Next[K] = 0 then}

^{Next[Prev[K]] := 0}

^else

^begin

^{Next[Prev[K]] := Next [K];}

^{Prev[Next[K]] := Prev[K];}

^end;

^end;

^{{if ReadKey = char(27) then Exit; }}

^{J := N;}

^{while (J > 1) and}

^{((Forvd[J] and (Block[J] = J)) or (not Forvd[J] and (Block[J] = 1))) do}

^begin

^{Forvd[J] := not Forvd[J];}

^{J := J-1;}

^end;

^{Вывод}

^Output1;

^{{ Output2; }}

^end;

^end.

7Обходы бинарных деревьев

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

Наиболее распространены три метода прохождения БД:

• в прямом порядке;

• в симметричном порядке;

• в обратном порядке;

Часто применяется и четвертый метод прохождения БД – в горизонтальном порядке.

В каждом из трех первых методов не требуется никаких действий для прохождения пустого дерева. Методы определяются рекурсивно, так что прохождение БД требует посещения корня и прохождения его левого и правого поддеревьев.

Прохождение БД в прямом порядке

(просмотр дерева в глубину):

1. Попасть в корень.

2. Пройти в прямом порядке левое поддерево.

3. Пройти в прямом порядке правое поддерево.

Применим этот метод к дереву, аналогичному примеру 6.

получим:

A B D H I E L M C F G

Прохождение БД в симметричном порядке:

1. Пройти в симметричном порядке левое поддерево.

2. Попасть в корень.

3. Пройти в симметричном порядке правое поддерево.

Применим этот метод к заданному дереву. Получим:

H D I B L E M A F C G

Прохождение БД в обратном порядке:

1. Пройти в обратном порядке левое поддерево.

2. Пройти в обратном порядке правое поддерево.

3. Попасть в корень.

Применим этот метод к заданному дереву. Получим:

H I D L M E B F G C A

Отдельно следует остановиться на прохождении БД в горизонтальном порядке или прохождении по уровням. Методы прохождения состоит в том, что последовательно выбираются все узлы уровня 0, затем уровня 1 и т. д.

Прохождение БД в горизонтальном порядке:

(просмотр дерева по уровням)

1. Установить уровень узла К = 0.

2. Выбрать все узлы уровня К.

3. Пока не достигнут максимальный уровень К := К + 1. Перейти на пункт 2.

Применим этот метод к заданному дереву. Получим:

A B C D E F G H I L M

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