С точки зрения пользователя очереди по приоритету новый интерфейс лишь немногим сложнее рассмотренного ранее. Код интерфейса класса расширенной очереди по приоритету TtdPriorityQueueEx приведен в листинге 9.9.

Листинг 9.9. Интерфейс класса TtdPriorityQueueEx

type TtdPQHandle = pointer;
TtdPriorityQueueEx = class private FCompare : TtdCompareFunc;
FHandles : pointer;
FList : TList;
FName : TtdNameString;
protected
function pqGetCount : integer;
procedure pqError (aErrorCode : integers-const aMethodName : TtdNameString);
procedure pqBubbleUp (aHandle : TtdPQHandle) ;
procedure pqTrickleDown(aHandle : TtdPQHandle);
public
constructor Create(aCompare : TtdCompareFunc);
destructor Destroy;
override;
procedure ChangePriority(aHandle : TtdPQHandle);
procedure Clear;
function Dequeue : pointers-function Enqueue (alt em : pointer) : TtdPQHandle;
function Examine : pointers-function IsEmpty : boolean;
function Remove(aHandle : TtdPQHandle) : pointers-property Count : integer read pqGetCount;
property Name : TtdNameString read FName write FName;
end;

Как видите, единственное реальное различие между этим классом и классом TtdPriorityQueue состоит в наличии методов Remove и ChangePriority и в том, что метод Enqueue возвращает дескриптор.

Так как же реализован этот интерфейс? Внутренне очередь, как обычно, содержит сортирующее дерево, но на этот раз она должна поддерживать определенную дополнительную информацию, чтобы иметь возможность отслеживать позицию каждого элемента в сортирующем дереве. Кроме того, очередь должна идентифицировать каждый элемент дескриптором, чтобы поиск элемента по заданному дескриптору выполнялся быстро и эффективно - теоретически быстрее, чем в дереве двоичного поиска, где время поиска определяется соотношением 0(log(«)).

Поэтому мы сделаем следующее: когда пользователь будет ставить элемент в очередь, мы будем добавлять элемент в связный список. Это будет сопряжено с определением и использованием узла и, по меньшей мере, двух указателей: указателя самого этого элемента и указателя следующего элемента, хотя по причинам, которые станут понятны несколько позже, мы будем использовать двухсвязный список и поэтому нам потребуется также и предыдущий указатель. Передаваемый нами обратно дескриптор элемента будет адресом узла. Теперь наступает важный момент. Узел хранит также целочисленное значение - позицию элемента в массиве, посредством которого реализовано сортирующее дерево. Сортирующее дерево не хранит сами элементы, а только их дескрипторы (т.е. узлы связного списка). Каждый раз, когда для выполнения сравнения ему нужно будет обратиться к самому элементу, оно будет разыменовывать дескриптор.

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

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

Листинг 9.10. Постановка в очередь и пузырьковый подъем в расширенной очереди по приоритету

procedure TtdPriorityQueueEx.pqBubbleUp(aHandle : pointer); var
Fromlnx : integer;
ParentInx : integer;
ParentHandle : PpqexNode;
Handle : PpqexNode absolute aHandle;
begin
{если анализируемый дескриптор больше дескриптора родительского элемента, нужно их нужно поменять местами и продолжить процесс с новой позиции)
{Примечание: родительский узел дочернего узла, имеющего индекс п, имеет индекс (п-1)/2)
Fromlnx := HandleА .pelnx;
if (Fromlnx > 0) then begin
ParentInx := (Fromlnx - 1) div2;
ParentHandle : - PpqexNode(FList.ListA[ParentInx]);

{если элемент имеет родительский элемент и больше нее о...} while (Fromlnx > 0) and

(FCompare (HandleA. peltem, ParentHandleA. peltem) > 0) do begin
{нужно переместить родительский элемент вниз по дереву)
FList.ListА[Fromlnx] : = ParentHandle;
ParentHandleA .pelnx := Fromlnx;
Fromlnx := ParentInx;
Parent Inx :«= (Fromlnx - 1) div2;
ParentHandle : = PpqexNode(FList.ListA[ParentInx]);
end;
end;
{сохранить элемент в правильной позиции) FList.Li stA[Fromlnx] : = Handle;
HandleA .pelnx : = Fromlnx;
end;
function TtdPriorityQueueEx.Enqueue(altem : pointer) : TtdPQHandle;
var
Handle : PpqexNode;
begin
{создать новый узел для связного списка)
Handle : = AddLinkedListNode(FHandles, altem);
{добавить дескриптор в конец очереди)
FList.Add(Handle);
HandleA.pelnx : = pred(FList.Count);
{теперь нужно выполнить его пузырьковый подъемна максимально возможный уровень) if (FList. Count > 1) then
pqBubbleUp(Handle); {вернуть дескриптор) Result := Handle;
end;

Подобно методу Enqueue, все эти косвенные ссылки несколько усложняют метод Dequeue, но в коде все же можно распознать стандартные операции исключения из очереди и просачивания.

Листинг 9.11. Исключение из очереди и просачивание в расширенной очереди по приоритету

procedure TtdPriorityQueueEx.pqTrickleDown(aHandle : TtdPQHandle); var
Fromlnx : integer;
Maxlnx : integer;
Childlnx : integer;
ChildHandle : PpqexNode;
Handle : PpqexNode absolute aHandle;
begin
{если анализируемый элемент меньше одного из своих дочерних элементов, его нужно поменять местами с большим дочерним элементом и продолжить процесс из новой позиции)
Fromlnx := HandleА.pelnx;
Maxlnx : = pred(FList.Count);
{вычислить индекс левого дочернего узла)
Childlnx := succ(Fromlnx * 2);

{если имеется по меньшей мере правый дочерний элемент, необходимо вычислить индекс большего дочернего элемента...} while (Childlnx <= Maxlnx) do begin {если есть хоть один правый дочерний узел, вычислить индекс наибольшего дочернего узла) if ((Childlnx+l) <= Maxlnx) and

(FCompare(PpqexNode(FList.ListA[Childlnx])A.peltern, PpqexNode(FList.ListA[Childlnx+l])A.peItem) < 0) then inc(Childlnx);
{если элемент больше или равен большему дочернему элементу, задача выполнена) ChildHandle : = PpqexNode(FList.ListА[Childlnx]);
if (FCompare (Handle A. pel tern, Chi ldHandleA .pel tern) >= 0) then Break;
{в противном случае больший дочерний элемент нужно переместить вверх по дереву, а сам элемент - вниз) FList.ListА[Fromlnx] ChildHandle;
ChildHandleA.pelnx := Fromlnx;
Fromlnx := Childlnx;
Childlnx := succ(Fromlnx * 2);
end;
{сохранить элемент в правильной позиции) FList.ListA[Fromlnx] := Handle;
HandleA.pelnx := Fromlnx;
end;
function TtdPriorityQueueEx.Dequeue : pointer;
var
Handle : PpqexNode;
begin
{проверить наличие элементов, которые нужно исключить из очереди) if (FList.Count = 0) then
pqError(tdeQueuelsEmpty, 1 Dequeue1); {вернуть корневой элемент, удалить его из списка дескрипторов) Handle : = FList.ListА[0]; Result := Handle А .ре I tern;
DeleteLinkedListNode(FHandles, Handle);

{если очередь содержала только один элемент, теперь она пуста} if (FList.Count = 1) then FList.Count := 0

{если она содержала два элемента, нужно просто заменить корневой элемент одним из оставшихся дочерних элементов. Очевидно, что при этом свойство пирамидальности сохраняется)
else if (FList. Count = 2) then begin
Handle : = FList.ListA[1] ; FList.ListA[0] := Handle;
FList.Count := 1; HandleA.pelnx := 0; end
{в противном случае свойство пирамидальности требует восстановления) else begin
{заменить корневой узел дочерним узлом, расположенным в самой нижней, крайней справа позиции, и уменьшить размер списка; затем за счет применения метода просачивания переместить корневой узел как можно дальше вниз по дереву) Handle := FList.Last;
FList.ListA[0] := Handler-HandleA .pelnx := 0; FList.Count := FList.Count - 1; pqTrickleDown(Handle);
ends-end;

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

Листинг 9.12. Восстановление свойства пирамидальности после изменения приоритета

procedure TtdPriorityQueueEx. ChangePriority (aHandle : TtdPQHandle) ; var
Handle : PpqexNode absolute aHandle;
ParentInx : integer;
ParentHandle : PpqexNode;
begin
{проверить возможность выполнения операции пузырькового подъема) if (HandleА.pelnx > 0) then begin
ParentInx := (HandleA.pelnx - 1) div 2;
ParentHandle := PpqexNode(FList[ParentInx]);
if (FCompare( Handle A .pel tern. Parent HandleA .pe Item) > 0) then begin
pqBubbleUp(Handle);
Exits-end;
end;
{в противном случае выполнить операцию просачивания) pqTrickleDown(Handle);
end;

Последняя операция реализуется при помощи метода Remove. В данном случае мы возвращаем элемент, определенный дескриптором, а затем заменяем его последним элементом сортирующего дерева. Дескриптор удаляется из связного списка. Эта операция упрощается благодаря использованию двусвязного списка. Затем значение счетчика элементов в сортирующем дереве уменьшается на единицу. С этого момента процесс полностью совпадает с процессом изменения приоритета, поэтому мы просто вызываем соответствующий метод.

Листинг 9.13. Удаление элемента, заданного его дескриптором

function TtdPriorityQueueEx. Remove (aHandle : TtdPQHandle) : pointer;
var
Handle : PpqexNode absolute aHandle;
NewHandle : PpqexNode;
Heaplnx : integer;
begin
{вернуть элемент, а затем удалить дескриптор) Result := HandleA.peltem;
Heaplnx := HandleA.pelnx;
DeleteLinkedListNode(FHandles, Handle);

{выполнить проверку того, что был удален последний элемент. Если это так, нужно просто уменьшить размер сортирующего дерева - при этом свойство пирамидальности будет сохранено) if (Heaplnx = pred(FList.Count)) then FList.Count := FList.Count - 1

else begin
{заменить элемент сортирующего дерева дочерним элементом, расположенным в самой нижней крайней справа позиции, и уменьшить размер списка) NewHandle := FList.Last;
FList.ListA[Heaplnx] : = NewHandle;
NewHandleA.pelnx : = Heaplnx;
FList.Count := FList.Count - 1;
{дальнейшие действия совпадают с выполнением операции изменения приоритета) ChangePriority(NewHandle);
end;
end;

Полный код этого класса можно найти на Web-сайте издательства, в разделе материалов. После выгрузки материалов отыщите среди них файл TDPriQue.pas.

Отыскание произвольного элемента в сортирующем дереве || Оглавление || Резюме9


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



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

  • Сентябрь
    2019
  • Пн
  • Вт
  • Ср
  • Чт
  • Пт
  • Сб
  • Вс