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

При обходе в ширину вначале мы посещаем корневой узел, затем, используя алгоритм обхода в ширину, выполняем обход левого дочернего дерева, а затем таким же образом выполняем обход правого дочернего дерева. (Обход дерева, изображенного на рис. 8.1, выполнялся бы в следующем порядке: d, b, а, с, /, е, g.) При симметричном обходе вначале выполняется обход левого дочернего дерева корневого узла с применением алгоритма симметричного обхода, а затем симметричный обход правого дочернего дерева. (В дереве, показанном на рис. 8.1, посещение узлов выполнялось бы в следующем порядке: а, Ь, с, d, е, /, g.) При обходе в глубину вначале выполняется обход в левого дочернего дерева с применением алгоритма обхода в глубину, затем таким же образом выполняется обход правого дочернего дерева, а затем посещается корневой узел. (В дереве, изображенном на рис. 8.1, посещение узлов выполнялось бы в следующем порядке: а, с, b, е, g, f, d.) Обход в глубину чаще всего применяется для уничтожения всех узлов в бинарном дереве, когда процесс уничтожения можно было бы описать следующим образом: "чтобы уничтожить все узлы в бинарном дереве, необходимо уничтожить левое дочернее дерево корневого узла, затем правое дочернее дерево корневого узла, а затем сам коревой узел".

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

Листинг 8.4. Обход в ширину, симметричный обход и обход в глубину

type TtdProcessNode = procedure (aNode : PtdBinaryNode);
procedure PreOrderTraverse(aRoot : PtdBinaryNode;
aProcessNode : TtdProcessNode);
begin
if (aNodeOnil) then begin aProcessNode(aRoot);
PreOrderTraverse(aRootA.bnChild[ciLeft], aProcessNode);
PreOrderTraverse(aRootл.bnChild[ciRight], aProcessNode);
end;
end;
procedure InOrderTraverse(aRoot : PtdBinaryNode;
aProcessNode : TtdProcessNode);
begin
if (aNodeonil) then begin
InOrderTraverse(aRoot*.bnChild[ciLeft], aProcessNode);
aProcessNode(aRoot);
InOrderTraverse(aRootA.bnChild[ciRight], aProcessNode);
end;
end;
procedure PostOrderTraverse(aRoot : PtdBinaryNode;
aProcessNode : TtdProcessNode);
begin
if (aNodeonil) then begin
PostOrderTraverse(aRoot*.bnChild[ciLeft], aProcessNode);
PostOrderTraverse(aRootA.bnChild[ciRight], aProcessNode);
aProcessNode(aRoot);
end;
end;

Обратите внимание на то, как каждая рекурсивная процедура проверяет, не является ли переданный ей узел нулевым. В этом случае она не выполняет никаких действий, немедленно осуществляя выход. Следовательно, со временем рекурсивный вызов процедур завершится (поскольку дерево простирается не до бесконечности).

Однако в каждом случае применения рекурсивной процедуры следует оценить, сколько раз она должна будет выполняться в ходе последовательности рекурсивных вызовов. Дело в том, что рекурсивные процедуры хранят свое состояние в стеке программы, размер которого в общем случае ограничен. Если выясняется, что рекурсивная процедура может иметь слишком много уровней, следует подумать над тем, как избавиться от рекурсии за счет применения внешнего стека. Используя внешний стек вместо стека программы, можно быть уверенным, что при необходимости размер стека в куче можно будет увеличить (пока выделенный объем кучи не будет исчерпан, однако, в общем случае этот объем значительно превышает размер стека программы).

Мы используем стек, созданный на основе связного списка класса TtdStack, который был описан в главе 3. Для выполнения обхода в ширину мы заталкиваем в стек корневой узел и выполняем цикл, который продолжается до тех пор, пока стек не опустеет. Мы выталкиваем из стека верхний узел и посещаем его. Если правая дочерняя связь этого узла является ненулевой, мы заталкиваем ее в стек. Затем заталкиваем в стек левую дочернюю связь узла, если она является ненулевой. (Заталкивание дочерних узлов в указанном порядке означает, что вначале из стека выталкивается левый дочерний узел.) Если стек не является пустым, цикл повторяется. Обход завершается немедленно после опустошения стека.

Листинг 8.5. Нерекурсивный обход в ширину

type TtdVisitProc = procedure ( aData : pointer;
aExtraData : pointer;
var aStopVisits : boolean ) ; function TtdBinaryTree.btNoRecPreOrder(aAction : TtdVisitProc;
aExtraData : pointer) : PtdBinTreeNode;
var
Stack : TtdStack;
Node : PtdBinTreeNode;
StopNow : boolean;

begin {предположим, что мы не добрались до выбранного узла] Result : = nil; StopNow := false; {создать стек} Stack := TtdStack.Create(nil); try

{затолкнуть корневой узел}
Stack.Push(FHeadA.btChild[ctLeft]);
{продолжать процесс до тех пор, пока стек не будет пуст}
while not Stack. IsEmpty do begin
{извлечь узел в начале очереди}
Node : = Stack. Pop ;
{выполнить с ним указанное действие; если в результате возвращаемое значение переменной StopNow равно true, вернуть этот узел} aAction(NodeA.btData, aExtraData, StopNow);
if StopNow then begin
Result := Node;

Stack.Clear; end {в лролшвном случае продолжить цикл} else begin {затолкнуть правую дочернюю связь, если она не нулевая} if (NodeA.btChild[ctRight]onil) then Stack.Push(NodeA.btChild[ctRight]); {затолкнуть левую дочернюю связь, если она не нулевая} if (NodeA.btChild[ctLeft]<>nil) then Stack.Push(NodeA.btChild[ctLeft]); end; end; finally

{уничтожить стек} Stack.Free;
end;
end;

Касательно кода, приведенного в листинге 8.5, следует сделать несколько замечаний. Во-первых, мы используем процедуру действия, которая несколько сложнее применявшейся ранее. Процедура типа TtdVisitProc предоставляет пользователю метода обхода большую степень управления процессом, а именно -возможность остановить обход. Т.е. пользователь класса бинарного дерева может выполнять действия как для каждой записи (посещая все узлы), так и для первой найденной записи (т.е. для поиска первого узла, удовлетворяющего заданному условию). Значение третьего параметра процедуры действия, aStopVisits, устанавливается равным false вызывающей процедурой, а если процедуре действия нужно остановить обход, это значение может быть установлено равным true (в этом случае метод обхода вернет элемент, который привел к возврату значения true процедурой действия).

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

Убедившись, насколько просто избавиться от рекурсии при обходе в ширину, можно было бы предположить, что это легко сделать и для остальных двух видов обхода. Однако, применяя это же подход к симметричному обходу и обходу в глубину, мы сталкиваемся с препятствием. Чтобы понять, о чем идет речь, рассмотрим исключение рекурсии для симметричного обхода тем же способом, который был применен для обхода в ширину. Теоретически в цикле нужно было бы затолкнуть в стек правый дочерний узел, затем сам узел, а затем левый дочерний узел. Далее, со временем, нужно было бы вытолкнуть узел из стека и выполнить его обработку. Но, вытолкнув узел из стека, как узнать, встречался ли он ранее? Если узел ранее встречался, его нужно посетить; если нет, его вместе с дочерними узлами необходимо затолкнуть в стек, но в правильном порядке.

В действительности нужно сделать следующие действия. Вытолкнуть узел из стека. Если ранее узел не встречался, нужно затолкнуть в стек правый дочерний узел, пометить узел как "встречавшийся", затолкнуть его, а затем затолкнуть в стек левый дочерний узел. Если ранее узел встречался (помните, что он уже помечен?), следует просто его обработать. Но как пометить узел? В конце концов, узел - это указатель, и в действительности не хотелось бы с ним возиться. Я предлагаю следующее решение: после заталкивания в стек "встречавшегося" узла нужно затолкнуть узел nil. В этом случае выталкивание из стека нулевого узла свидетельствует о том, что следующий узел в стеке является тем, который должен быть обработан.

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

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

Листинг 8.6. Нерекурсивный симметричный обход

function TtdBinaryTree.btNoRecInOrder(aAction : TtdVisitProc;
aExtraData : pointer) : PtdBinTreeNode;

var Stack : TtdStack; Node : PtdBinTreeNode; StopNow : boolean; begin {предположим, что мы не добрались до выбранного узла) Result := nil; StopNow := false; {создать стек} Stack : = TtdStack.Create(nil); try

{затолкнуть корневой узел)
Stack.Push(FHeadA.btChild[ctLeft]);
{продолжать процесс до тех пор, пока стек не опустеет)
while not Stack. IsEmpty do begin
{извлечь узел в начале очереди}
Node : = Stack.Pop;
{если он является нулевым, вытолкнуть из стека следующий узел и выполнить с ним указанное действие. Если в результате возвращается запрос на прекращение обхода, вернуть этот узел} if (Node = nil) then begin Node : = Stack.Pop;
aAction(Nodeл.btData, aExtraData, StopNow);
if StopNow then begin
Result := Node;
Stack, deadend;
end
{в противном случае дочерние узлы этого узла в стек еще не заталкивались} else begin
{затолкнуть правый дочерний узел, если он не нулевой} if (NodeA.btChild[ctRight]onil) then Stack.Push(NodeA.btChild[ctRight]); {затолкнуть узел, а за ним - нулевой указатель} Stack.Push(Node);
Stack.Push(nil);

{затолкнуть левый дочерний узел, если он не нулевой} if (NodeA.BtChild[ctLeft]onil) then Stack.Push(NodeA.btChild[ctLeft]); end; end; finally

{уничтожить стек} Stack.Free;
end;
end;

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

Листинг 8.7. Нерекурсивный обход в глубину

function TtdBinaryTree.btNoRecPostOrder(aAction : TtdVisitProc;
aExtraData : pointer) : PtdBinTreeNode;

var Stack : TtdStack; Node : PtdBinTreeNode; StopNow : boolean; begin {предположим, что мы не добрались до выбранного узла} Result := nil; StopNow := false; {создать стек} Stack := TtdStack.Create(nil) ; try

{затолкнуть корневой узел}
Stack.Push(FHeadA.btChild[ctLeft]);
{продолжать процесс до тех пор, пока стек не опустеет}
while not Stack. IsEmpty do begin
{извлечь узел в начале очереди}
Node : = Stack. Pop ;
{если он является нулевым, вытолкнуть из стека следующий узел и выполнить с ним указанное действие. Если в результате возвращается значение false (т.е. обход должен быть прекращен), вернуть этот узел}
if (Node = nil) then begin Node := Stack.Pop;
aAction(NodeЛ.btData, aExtraData, StopNow);
if StopNow then begin Result := Node;
Stack, deadend;
end
{в противном случае дочерние узлы этого узла в стек еще не заталкивались} else begin
{затолкнуть узел, а за ним - нулевой указатель} Stack.Push(Node);
Stack.Push(nil);
{затолкнуть правый дочерний узел, если он не нулевой} if (NodeA.btChild[ctRight]onil) then Stack.Push(NodeA.btChild[ctRight]);

{затолкнуть левый дочерний узел, если он не нулевой} if (NodeA.btChild[ctLeft]<>nil) then Stack.Push(NodeA.btChild[ctLeft]); end; end; finally

{уничтожить стек] Stack.Free;
end;
end;

Как и ранее, по тем же причинам, метод предполагает, что дерево является не пустым.

Перемещение по бинарному дереву || Оглавление || Обход по уровням


Фундаментальные алгоритмы и структуры данных в Delphi



Новости за месяц

  • Июнь
    2019
  • Пн
  • Вт
  • Ср
  • Чт
  • Пт
  • Сб
  • Вс