Chapter 7

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

Дефиниция и приложения
Ключове, приоритети и релации на пълна наредба
Операции на приоритетна опашка АТД и приложения
Сортиране с приоритетна опашка
Композиции и компаратори
Реализация на приоритетна опашка АТД с редица АТД
Сортиране чрез избор (Selection-Sort)
Сортиране чрез вмъкване (Insertion-Sort)

Приоритетна опашка

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

Примери:

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

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

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

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

Ключовете в приоритетна опашка може да бъдат произволни обекти, за които е дефинирана наредба.
Два различни елемента в приоритетната опашка могат да имат еднакви ключове.

Сравняване на ключове:

Математическо понятие за релация на частична наредба ≤ (правило за сравняване на ключове):

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

Пример: Множество от възлинте на двоично дърво и наредба родител ≤ наследник.
Най-малъкия ключ е или ≤ или е несравним с всеки ключ от множеството;
Линейна (пълна) наредба - всеки два ключа са сравними, т.е. за всеки x, y: или x ≤ y или y ≤ x.
Пример: Наредбата по-малко или равно в множество от числа.

Операции на приоритетна опашка АТД и приложения

Приоритетна опашка АТД съхранява съвкупност от обекти (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) и removeMin(), което зависи от реализацията на приоритетната опашка.

Пример за действието на функциите на приоритетната опашка АТД

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	{}

Композиции и компаратори (comparators)

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

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

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

html-7.2 (Item)

item.cpp

Компаратор-шаблон

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

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)

comp.cpp

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

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

Добавяне на нова двойка (обект) 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) ()

Select-sort with Gypsy folk dance

Сортиране чрез вмъкване (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) ()

Insert-sort with Romanian folk dance