Chapter 7

Приоритетна опашка - първа част

Приоритетна опашка е АТД за съхраняване на съвкупност от обекти (items) с приоритети, която поддържа вмъкване и премахване на обект, като премахването става по приоритет, т.е. обектът с първи приоритет се премахва най-напред.
Примери:

Чакащ за място пътник за напълно резервиран полет - приоритетът тук се измерва по отношение на цената на билета, често-пътуващ статус на клиента и времето на регистрацията.
Във всяка операционна система, всеки процес има приоритет и планировчика (scheduler) избира процес с по-висок приоритет пред този с по-нисък приоритет.

Приоритетът обикновено е числова стойност - най-малката стойност означава най-висок приоритет.

Ключове, приоритети и релации на пълна наредба

Ще дефинираме ключ като обект (object), прикачен към някой елемент като специфичен атрибут, който може да бъде използван за идентификация, ранг, или тегло на този елемент.

Сравняване на ключове и пълна наредба

Ключовете в приоритетна опашка може да бъдат произволни обекти, за които е дефинирана наредба.
Два отделни членове в приоритетната опашка могат да имат еднакъв ключ.
Математическо понятие за релация на пълна наредба ≤ (правило за сравняване на ключове):

Рефлексивност: x ≤ x.
Антисиметричност: x ≤ y ∧ y ≤ x ⇒ x = y.
Транзитивност: x ≤ y ∧ y ≤ z ⇒ x ≤ z.

Най-малък ключ: ≤ от всеки ключ от множеството; линейна наредба.

Приоритетна опашка АТД съхранява съвкупност от обекти (items), без да използва позиции.
Всеки обект е наредена двойка (ключ, елемент) - (k,e).
Основни методи:

insertItem(k,e) - вмъква обект с ключ k и елемент e;
removeMin() - премахва обекта с най-малък ключ.

Допълнителни методи:

minKey() - връща ключ на обекта с най-малък ключ;
minElement() - връща елемента на обекта с най-малък ключ;
size(), isEmpty()

Приложения:

Чакащ за място пътник

Да предположим, че даден полет е изцяло запълнен един час преди началото на пътуването. Поради възможността за отказване (анулиране), авиокомпанията поддържа приоритетната опашка на чакащите за място пътници. Приоритетът на всеки пътник се определя от стойността на билета, често-пътуващ статут (frequent-flyer status), както от и времето, когато пътникът е поставен в приоритетната опашка. Когато пътник се регистрира като чакащ за място, свързаният с пътника обект се добавя в приоритетната опашка с операция insertItem. Малко преди излитането на самолета, ако станат достъпни места (например, поради отказване в последната минута), авиокомпанията многократно премахва от приоритетната опашка чакащ за място пътник с първи приоритет, като се използва комбинация от minElement() и removeMin() операции и качва този пътник на самолета.

Сортиране с приоритетна опашка

Ще използваме приоритетна опашка за сортиране на множество от сравними елементи:

Добавяме елементите един по един със серия от insertItem(e,e) операции.
Премахваме елементите в нарастващ ред със серия от removeMin() операции.

Времето за работа на този метод на сортиране зависи от реализацията на приоритетната опашка АТД.

Algorithm PriorityQueueSort(S, P):
Input: Редица S съдържаща n елемента, за които е дефинирана пълна наредба
    и опашка с приоритети P, която сравнява ключове със същата пълна наредба
Output: Редица S наредена с тази наредба
while !S.isEmpty() do
   e <- S.removeFirst()   { премахва елемент e от S }
   P.insertItem(e,e)         { ключът е самия елемент }
while !P.isEmpty() do
   e <- P.minElement()    { взема на-малкия елемент от P }
   P.removeMin()               { премахва този елемент от P }
   S.insertLast(e)             { добавя елемента към края на S }

Времето за работа на този алгоритъм зависи от времето за изпълнение на операциите insertItem(e,e), minElement() и removeMin(), което зависи как е реализирана приоритетната опашка P.
Пример:

Operation	Output	Priority Queue
insertItem(5,A)	-	{(5,A)}
insertItem(9,C)	-	{(5,A),(9,C)}
insertItem(3,B)	-	{(3,B),(5,A),(9,C)}
insertItem(7,D)	-	{(3,B),(5,A),(7,D),(9,C)}
minElement()	B	{(3,B),(5,A),(7,D),(9,C)}
minKey()	3	{(3,B),(5,A),(7,D),(9,C)}
removeMin()	-	{(5,A),(7,D),(9,C)}
size()	3	{(5,A),(7,D),(9,C)}
minElement()	A	{(5,A),(7,D),(9,C)}
removeMin()	-	{(7,D),(9,C)}
removeMin()	-	{(9,C)}
removeMin()	-	{}
removeMin()	ERROR	{}
isEmpty()	true	{}

Все още има два важни въпроса, които са останали неопределени до този момент:

Как да се пазят връзките между елементите и техните ключове?
Как да се сравняват ключовете, за да се определи най-малък ключ?

Композиции и компаратори

Композиция-шаблон

Композиция-шаблон дефинира обект, който е композиция от други обекти.
Двойката (k,e) е най-простата композиция, която свързва два обекта k и e в един обект - наредена двойка (pair).

html-7.2 (Item)

Компаратор

Компараторът капсулира действието сравнение на два обекти по зададена линейна наредба.
Когато приоритетната опашка трябва да сравнява два ключа, тя използва компаратор.
Най-общо, приоритетна опашка използва компаратор (като аргумент на шаблона) за определяне на функция за сравнение (<, =, >).
Пример: Предефиниране на операция лексикографски по-малко:

bool operator<(const Point& p1, const Point& p2)
{ if (p1.getX() == p2.getX()) return p1.getY() < p2.getY();
  else return p1.getX() < p1.getX();
}

Компараторът е външен за ключовете, които се сравняват. По този начин същите обекти могат да бъдат сортирани по различни начини с помощта на различни компаратори.
Нека comp е обект от класа на компаратора. comp(a,b) връща цяло число i, такова, че

i < 0 ако a < b,
i = 0 ако a = b, and
i > 0 ако a > b.

Ще приложим подхода с предефиниране на операция "()", като конструираме т.н. функционални обекти.

Пример: Сравняване на две точки в равнината лексикографски.

class LexCompare {
public:
   int operator()(Point a, Point b) {
   if (a.x < b.x) return –1
   else if (a.x > b.x) return +1

   else if (a.y < b.y) return –1
   else if (a.y > b.y) return +1
   else return 0;
   }
};

html-7.3 (Compare)

Използване на компаратора

За да използваме компаратор, дефинираме обект от този клас и го използваме с помощта на неговата предефинирана "()" операция.
Например:

Point p(2.3, 4.5);
Point q(1.7, 7.3);
LexCompare lexCompare;
if (lexCompare(p, q) < 0) cout << “p less than q”;
else if (lexCompare(p, q) == 0) cout << “p equals q”;
else if (lexCompare(p, q) > 0) cout << “p greater than q”;

html-7.4 (Generic)

Реализация на приоритетна опашка АТД с редица АТД

Реализация е несортирана редица

Добавяне на нова двойка (обект) p = (k,e) към края на редицата S става с изпълнение на функцията insertLast(p) от S - време O(1), независимо от реализацията на редица АТД - с масив или със свързан списък.
За операциите minElement(), minKey() и removeMin() от P, трябва да се посетят всички елементи на редицата S, за да се намери елемент p = (k,e) от S с най-малко k - време O(n).

Реализация със сортирана редица

minElement()и minKey() се реализират в P като се вземе първия елемент на редицата S с функцията first(). Реализацията на removeMin() от P е S.remove(S.first()) - време O(1).
Функцията insertItem(k,e) от P изисква да се претърси редицата S за да се намери правилното място за вмъкване на новия обект (ключ, елемент) - време O(n).

html-7.5 (SSPQ1)
html-7.6 (SSPQ2)

[priority.cpp]

Сравнение на двете реализации

Реализация с ненаредена редица Съхранява обектите на приоритетната редица в редица АТД, (реализирана със свързан списък) в произволен ред.	Реализация с наредена редица Съхранява обектите на приоритетната редица в редица АТД, сортирани по ключ
Бързодействие: insertItem отнема време O(1), защото обектът може да се добави в началото или в края на редицата; removeMin, minKey и minElement отнемат време O(n), защото трябва да се обходи цялата редица за да се намери най-малкия ключ.	Бързодействие: insertItem отнема време O(n), защото трябва да се намери мястото, където да се вмъкне новия обект; removeMin, minKey и minElement отнемат време O(1), защото най-малкият ключ е в началото на редицата.

Сортиране чрез избор (Selection-Sort)

Сортиране чрез избор е вариант на PriorityQueueSort където приоритетната опашка е реализирана с несортирана редица.
Време за изпълнение на сортиране чрез избор:

Вмъкване на обектите в приоритетната опашка с n insertItem операции отнема време O(n).
Изваждане на обект в нарастващ ред от приоритетната опашка с n операции removeMin отнема време, пропорционално на 1 + 2 + …+ n.

Сортиране чрез избор се изпълнява за време O(n²).

	Sequence S	Priority Queue P (unsorted sequence)
Input	(7,4,8,2,5,3,9)	()
Phase 1 O(n)	(4,8,2,5,3,9) (8,2,5,3,9) (2,5,3,9) (5,3,9) (3,9) (9) ()	(7) (7,4) (7,4,8) (7,4,8,2) (7,4,8,2,5) (7,4,8,2,5,3) (7,4,8,2,5,3,9)
Phase 2 O(n^₂)	(2) (2,3) (2,3,4) (2,3,4,5) (2,3,4,5,7) (2,3,4,5,7,8) (2,3,4,5,7,8,9)	(7,4,8,5,3,9) (7,4,8,5,9) (7,8,5,9) (7,8,9) (8,9) (9) ()

Сортиране чрез вмъкване (Insertion-Sort)

Сортиране чрз вмъкване е вариант на PriorityQueueSort, където приоритетната опашка е реaлизирана с наредена редица.
Време за изпълнение на сортиране чрез вмъкване:

Вмъкване на обектите в приоритетната опашка с n операции insertItem отнема време, пропорционално на 1 + 2 + …+ n.
Изваждане на обект (в нарастващ ред) от приоритетната опашка със серия от n removeMin операции отнема време O(n).

Сортиране чрез вмъкване се изпълнява за време O(n²).

	Sequence S	Priority Queue P (sorted sequence)
Input	(7,4,8,2,5,3,9)	()
Phase 1 O(n^₂)	(4,8,2,5,3,9) (8,2,5,3,9) (2,5,3,9) (5,3,9) (3,9) (9) ()	(7) (4,7) (4,7,8) (2,4,7,8) (2,4,5,7,8) (2,3,4,5,7,8) (2,3,4,5,7,8,9)
Phase 2 O(n)	(2) (2,3) (2,3,4) (2,3,4,5) (2,3,4,5,7) (2,3,4,5,7,8) (2,3,4,5,7,8,9)	(3,4,5,7,8,9) (4,5,7,8,9) (5,7,8,9) (7,8,9) (8,9) (9) ()