09 Priority Queues Hongfei Yan Apr. 27, 2016.

Slides:



Advertisements
Similar presentations
© 2004 Goodrich, Tamassia Heaps © 2004 Goodrich, Tamassia Heaps2 Recall Priority Queue ADT (§ 7.1.3) A priority queue stores a collection of.
Advertisements

Heaps1 Part-D2 Heaps Heaps2 Recall Priority Queue ADT (§ 7.1.3) A priority queue stores a collection of entries Each entry is a pair (key, value)
Data Structures Lecture 7 Fang Yu Department of Management Information Systems National Chengchi University Fall 2010.
The Priority Queue Abstract Data Type. Heaps. Adaptable Priority Queue. 2 CPSC 3200 University of Tennessee at Chattanooga – Summer 2013 © 2010 Goodrich,
CSC401 – Analysis of Algorithms Lecture Notes 5 Heaps and Hash Tables Objectives: Introduce Heaps, Heap-sorting, and Heap- construction Analyze the performance.
© 2004 Goodrich, Tamassia Priority Queues1 Heaps: Tree-based Implementation of a Priority Queue.
Chapter 8: Priority Queues
© 2004 Goodrich, Tamassia Heaps © 2004 Goodrich, Tamassia Heaps2 Priority Queue Sorting (§ 8.1.4) We can use a priority queue to sort a set.
Priority Queues1 Part-D1 Priority Queues. Priority Queues2 Priority Queue ADT (§ 7.1.3) A priority queue stores a collection of entries Each entry is.
Chapter 8: Priority Queues and Heaps Nancy Amato Parasol Lab, Dept. CSE, Texas A&M University Acknowledgement: These slides are adapted from slides provided.
1 Priority Queues CPS212 Gordon College VIP. 2 Introduction to STL Priority Queues Adaptor container - underlying container may be either: – a template.
© 2004 Goodrich, Tamassia Priority Queues1. © 2004 Goodrich, Tamassia Priority Queues2 Priority Queue ADT (§ 7.1.3) A priority queue stores a collection.
Heaps and Priority Queues Priority Queue ADT (§ 2.4.1) A priority queue stores a collection of items An item is a pair (key, element) Main.
Adaptable Priority Queues1 3 a 5 g 4 e © 2010 Goodrich, Tamassia.
Priority Queues & Heaps Chapter 9. Iterable Collection Abstract Collection Queue List Abstract Queue Priority Queue Array List Abstract List Vector Stack.
PRIORITY QUEUES AND HEAPS CS16: Introduction to Data Structures & Algorithms Tuesday, February 24,
1 Heaps A heap is a binary tree. A heap is best implemented in sequential representation (using an array). Two important uses of heaps are: –(i) efficient.
Priority Queues and Heaps. Outline and Reading PriorityQueue ADT (§8.1) Total order relation (§8.1.1) Comparator ADT (§8.1.2) Sorting with a Priority.
Chapter 2.4: Priority Queues and Heaps PriorityQueue ADT (§2.4.1) Total order relation (§2.4.1) Comparator ADT (§2.4.1) Sorting with a priority queue (§2.4.2)
Chapter 2: Basic Data Structures. Spring 2003CS 3152 Basic Data Structures Stacks Queues Vectors, Linked Lists Trees (Including Balanced Trees) Priority.
CS 2468: Assignment 2 (Due Week 9, Tuesday. Drop a hard copy in Mail Box 75 or hand in during the lecture) Use array representation (double a[]) to implement.
1 Heaps A heap is a binary tree. A heap is best implemented in sequential representation (using an array). Two important uses of heaps are: –(i) efficient.
Heaps © 2010 Goodrich, Tamassia. Heaps2 Priority Queue ADT  A priority queue (PQ) stores a collection of entries  Typically, an entry is a.
Priority Queues Last Update: Oct 23, 2014 EECS2011: Priority Queues1.
Adaptable Priority Queues1 3 a 5 g 4 e © 2013 Goodrich, Tamassia, Goldwasser.
1 COMP9024: Data Structures and Algorithms Week Seven: Priority Queues Hui Wu Session 1, 2016
Adaptable Priority Queues1 3 a 5 g 4 e © 2014 Goodrich, Tamassia, Goldwasser Presentation for use with the textbook Data Structures and Algorithms in Java,
Heaps and Priority Queues What is a heap? A heap is a binary tree storing keys at its internal nodes and satisfying the following properties:
Sorting With Priority Queue In-place Extra O(N) space
Priority Queues 5/3/2018 Presentation for use with the textbook Data Structures and Algorithms in Java, 6th edition, by M. T. Goodrich, R. Tamassia, and.
Heaps (8.3) CSE 2011 Winter May 2018.
Priority Queues © 2010 Goodrich, Tamassia Priority Queues 1
Heaps 8/2/2018 Presentation for use with the textbook Data Structures and Algorithms in Java, 6th edition, by M. T. Goodrich, R. Tamassia, and M. H. Goldwasser,
Priority Queues Chuan-Ming Liu
COMP9024: Data Structures and Algorithms
Part-D1 Priority Queues
Heaps © 2010 Goodrich, Tamassia Heaps Heaps
Bohyung Han CSE, POSTECH
Heaps 9/13/2018 3:17 PM Heaps Heaps.
Chapter 2: Basic Data Structures
Heaps and Priority Queues
Chapter 2, Sections 4 and 5 Priority Queues Heaps Dictionaries
Priority Queues and Heaps
Part-D1 Priority Queues
Heaps and Priority Queues
Priority Queues 4/6/15 Presentation for use with the textbook Data Structures and Algorithms in Java, 6th edition, by M. T. Goodrich, R. Tamassia, and.
Heaps 11/27/ :05 PM Heaps Heaps.
Tree Representation Heap.
Heaps A heap is a binary tree.
Heaps and Priority Queues
© 2013 Goodrich, Tamassia, Goldwasser
Copyright © Aiman Hanna All rights reserved
Heaps 12/4/2018 5:27 AM Heaps /4/2018 5:27 AM Heaps.
Ch. 8 Priority Queues And Heaps
Priority Queues Sell 100 IBM $ $120 Buy 500 $ $118
Heaps and Priority Queues
Copyright © Aiman Hanna All rights reserved
Priority Queues Sell 100 IBM $ $120 Buy 500 $ $118
© 2013 Goodrich, Tamassia, Goldwasser
Adaptable Priority Queues
Heaps © 2014 Goodrich, Tamassia, Goldwasser Heaps Heaps
Lecture 9 CS2013.
Heaps and Priority Queues
Priority Queues © 2010 Goodrich, Tamassia Priority Queues
1 Lecture 10 CS2013.
CS210- Lecture 15 July 7, 2005 Agenda Median Heaps Adaptable PQ
CS210- Lecture 14 July 5, 2005 Agenda Inserting into Heap
Heaps 9/29/2019 5:43 PM Heaps Heaps.
CS210- Lecture 13 June 28, 2005 Agenda Heaps Complete Binary Tree
Data Structures & Programming
Presentation transcript:

09 Priority Queues Hongfei Yan Apr. 27, 2016

Contents 01 Python Primer (P2-51) 02 Object-Oriented Programming (P57-103) 03 Algorithm Analysis (P111-141) 04 Recursion (P150-180) 05 Array-Based Sequences (P184-224) 06 Stacks, Queues, and Deques (P229-250) 07 Linked Lists (P256-294) 08 Trees (P300-352) 09 Priority Queues (P363-395) 10 Maps, Hash Tables, and Skip Lists (P402-452) 11 Search Trees (P460-528) 12 Sorting and Selection (P537-574) 13 Text Processing (P582-613) 14 Graph Algorithms (P620-686) 15 Memory Management and B-Trees (P698-717) ISLR_Print6

Contents 9.1 The Priority Queue 9.2 Implementing a Priority Queue 9.3 Heaps 9.4 Sorting with a Priority Queue 9.5 Adaptable Priority Queues

Preview

9.1 The Priority Queue Abstract Data Type 9.1.1 Priorities 9.1.2 The Priority Queue ADT

E.g., An air-traffic control center that has to decide which flight to clear for landing This choice may be influenced by factors such as each plane’s distance from the runway, time spent waiting in a holding pattern, or amount of remaining fuel. It is unlikely that the landing decisions are based purely on a FIFO policy.

E.g., To use another airline analogy suppose a certain flight is fully booked an hour prior to departure. Because of the possibility of cancellations, the airline maintains a queue of standby passengers hoping to get a seat. Although the priority of a standby passenger is influenced by the check-in time of that passenger, other considerations include the fare paid and frequent-flyer status. So it may be that an available seat is given to a passenger who has arrived later than another, if such a passenger is assigned a better priority by the airline agent.

Priority Queue A new abstract data type known as a priority queue. This is a collection of prioritized elements that allows arbitrary element insertion, and allows the removal of the element that has first priority. When an element is added to a priority queue, the user designates its priority by providing an associated key. The element with the minimum key will be the next to be removed from the queue

Total Order Relations Keys in a priority queue can be arbitrary objects on which an order is defined Two distinct entries in a priority queue can have the same key Mathematical concept of total order relation  Reflexive property: x  x Antisymmetric property: x  y  y  x  x = y Transitive property: x  y  y  z  x  z

Priority Queue ADT Additional methods Applications: A priority queue stores a collection of items Each item is a pair (key, value) Main methods of the Priority Queue ADT add (k, x) inserts an item with key k and value x remove_min() removes and returns the item with smallest key Additional methods min() returns, but does not remove, an item with smallest key len(P), is_empty() Applications: Standby flyers Auctions Stock market

Priority Queue Example

9.2 Implementing a Priority Queue 9.2.1 The Composition Design Pattern 9.2.2 Implementation with an Unsorted List 9.2.3 Implementation with a Sorted List In this section, we show how to implement a priority queue by storing its entries in a positional list L. (See Section 7.4.) We provide two realizations, depending on whether or not we keep the entries in L sorted by key.

9.2.1 Composition Design Pattern An item in a priority queue is simply a key-value pair Priority queues store items to allow for efficient insertion and removal based on keys reminiscent 英 [ ˌremɪˈnɪsnt ] 美 [ ˌrɛməˈnɪsənt ]   adj.怀旧的; 回忆往事的; 使人联想…的 n.回忆录作者

Sequence-based Priority Queue Implementation with an unsorted list Performance: add takes O(1) time since we can insert the item at the beginning or end of the sequence remove_min and min take O(n) time since we have to traverse the entire sequence to find the smallest key Implementation with a sorted list Performance: add takes O(n) time since we have to find the place where to insert the item remove_min and min take O(1) time, since the smallest key is at the beginning 4 5 2 3 1 1 2 3 4 5

9.2.2 Unsorted List Implementation

9.2.3 Sorted List Implementation

2 6 5 7 9 9.3 Heaps 9.3.1 The Heap Data Structure 9.3.2 Implementing a Priority Queue with a Heap 9.3.3 Array-Based Representation of a Complete Binary Tree 9.3.4 Python Heap Implementation 9.3.5 Analysis of a Heap-Based Priority Queue 9.3.7 Python’s heapq Module

9.3.1 The Heaps Data Structure 9/12/2018 3:26 PM 9.3.1 The Heaps Data Structure A heap is a binary tree storing keys at its nodes and satisfying the following properties: Heap-Order: for every position v other than the root, key(v)  key(parent(v)) Complete Binary Tree: let h be the height of the heap for i = 0, … , h - 1, there are 2i nodes of depth i and the remaining nodes at level h reside in the leftmost possible positions at that level. The last node of a heap is the rightmost node of maximum depth 2 5 6 9 7 last node

Height of a Heap Let h be the height of a heap storing n keys Theorem: A heap storing n keys has height O(log n) Proof: (we apply the complete binary tree property) Let h be the height of a heap storing n keys Since there are 2i keys at depth i = 0, … , h - 1 and at least one key at depth h, we have n  1 + 2 + 4 + … + 2h-1 + 1 Thus, n  2h , i.e., h  log n depth keys 1 Theorem 英 [ ˈθɪərəm ] 美 [ ˈθiərəm ] n.[数] 定理; (能证明的)一般原理,公理,定律,法则 1 2 h-1 2h-1 h 1

9.3.2 Implementing a Priority Queues with a Heap Use a heap to implement a priority queue Store a (key, element) item at each internal node Keep track of the position of the last node (2, Sue) (5, Pat) (6, Mark) (9, Jeff) (7, Anna)

Adding an Item to the Heap Method add of the priority queue ADT corresponds to the insertion of a key k to the heap The insertion algorithm consists of three steps Find the insertion node z (the new last node) Store k at z Restore the heap-order property (discussed next) 2 6 5 7 9 insertion node 1 z

Up-Heap Bubbling After an Insertion After the insertion of a new key k, the heap-order property may be violated Algorithm up-heap restores the heap-order property by swapping k along an upward path from the insertion node Up-heap terminates when the key k reaches the root or a node whose parent has a key smaller than or equal to k Since a heap has height O(log n), up-heap runs in O(log n) time 2 1 5 1 5 2 z z 9 7 6 9 7 6

Removing the Item with Minimum Key Method remove_min of the priority queue ADT corresponds to the removal of the root key from the heap The removal algorithm consists of three steps Replace the root key with the key of the last node w Remove w Restore the heap-order property (discussed next) 2 5 6 w 9 7 last node 7 5 6 w 9 new last node

Down-Heap Bubbling After a Removal After replacing the root key with the key k of the last node, the heap-order property may be violated Algorithm down-heap restores the heap-order property by swapping key k along a downward path from the root Down-heap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), down-heap runs in O(log n) time 7 5 5 6 7 6 w w 9 9

9.3.3 Array-based Heap Implementation We can represent a heap with n keys by means of an array of length n For the node at rank i the left child is at rank 2i + 1 the right child is at rank 2i + 2 Links between nodes are not explicitly stored Operation add corresponds to inserting at rank n + 1 Operation remove_min corresponds to removing at rank n Yields in-place heap-sort 2 5 6 9 7 2 5 6 9 7 1 3 4

9.3.4 Python Heap Implementation

Merging Two Heaps We are given two heaps and a key k 3 2 We are given two heaps and a key k We create a new heap with the root node storing k and with the two heaps as subtrees We perform down-heap to restore the heap-order property 8 5 4 6 7 3 2 8 5 4 6 2 3 4 8 5 7 6

Bottom-up Heap Construction We can construct a heap storing n given keys in using a bottom-up construction with log n phases In phase i, pairs of heaps with 2i -1 keys are merged into heaps with 2i+1-1 keys 2i -1 2i+1-1

Example 16 15 4 12 6 7 23 20 25 5 11 27 16 15 4 12 6 7 23 20

Example (contd.) 25 5 11 27 16 15 4 12 6 9 23 20 15 4 6 23 16 25 5 12 11 9 27 20

Example (contd.) 7 8 15 4 6 23 16 25 5 12 11 9 27 20 4 6 15 5 8 23 16 25 7 12 11 9 27 20

Example (end) 10 4 6 15 5 8 23 16 25 7 12 11 9 27 20 4 5 6 15 7 8 23 16 25 10 12 11 9 27 20

9.3.5 Analysis of Heap Construction We visualize the worst-case time of a down-heap with a proxy path that goes first right and then repeatedly goes left until the bottom of the heap (this path may differ from the actual down-heap path) Since each node is traversed by at most two proxy paths, the total number of nodes of the proxy paths is O(n) Thus, bottom-up heap construction runs in O(n) time Bottom-up heap construction is faster than n successive insertions and speeds up the first phase of heap-sort

9.4 Sorting with a Priority Queue 9.4.1 Selection-Sort and Insertion-Sort 9.4.2 Heap-Sort

Priority Queues 9/12/2018 3:26 PM 9.4.1 Selection-Sort Selection-sort is the variation of PQ-sort where the priority queue is implemented with an unsorted sequence Running time of Selection-sort: Inserting the elements into the priority queue with n insert operations takes O(n) time Removing the elements in sorted order from the priority queue with n removeMin operations takes time proportional to 1 + 2 + …+ n Selection-sort runs in O(n2) time the bottleneck computation is the repeated “selection” of the minimum element in Phase 2. For this reason, this algorithm is better known as selection-sort. (See Figure 9.7.)

Selection-Sort Example Sequence S Priority Queue P Input: (7,4,8,2,5,3,9) () Phase 1 (a) (4,8,2,5,3,9) (7) (b) (8,2,5,3,9) (7,4) .. .. .. (g) () (7,4,8,2,5,3,9) Phase 2 (a) (2) (7,4,8,5,3,9) (b) (2,3) (7,4,8,5,9) (c) (2,3,4) (7,8,5,9) (d) (2,3,4,5) (7,8,9) (e) (2,3,4,5,7) (8,9) (f) (2,3,4,5,7,8) (9) (g) (2,3,4,5,7,8,9) ()

Priority Queues 9/12/2018 3:26 PM 9.4.1 Insertion-Sort Insertion-sort is the variation of PQ-sort where the priority queue is implemented with a sorted sequence Running time of Insertion-sort: Inserting the elements into the priority queue with n insert operations takes time proportional to 1 + 2 + …+ n Removing the elements in sorted order from the priority queue with a series of n removeMin operations takes O(n) time Insertion-sort runs in O(n2) time

Insertion-Sort Example Sequence S Priority queue P Input: (7,4,8,2,5,3,9) () Phase 1 (a) (4,8,2,5,3,9) (7) (b) (8,2,5,3,9) (4,7) (c) (2,5,3,9) (4,7,8) (d) (5,3,9) (2,4,7,8) (e) (3,9) (2,4,5,7,8) (f) (9) (2,3,4,5,7,8) (g) () (2,3,4,5,7,8,9) Phase 2 (a) (2) (3,4,5,7,8,9) (b) (2,3) (4,5,7,8,9) .. .. .. (g) (2,3,4,5,7,8,9) ()

In-place Insertion-Sort Instead of using an external data structure, we can implement selection-sort and insertion-sort in-place A portion of the input sequence itself serves as the priority queue For in-place insertion-sort We keep sorted the initial portion of the sequence We can use swaps instead of modifying the sequence 5 4 2 3 1 5 4 2 3 1 4 5 2 3 1 2 4 5 3 1 2 3 4 5 1 1 2 3 4 5 1 2 3 4 5

9.4.2 Heap-based Priority Queue Sorting Use a priority queue to sort a set of comparable elements Insert the elements one by one with a series of add operations Remove the elements in sorted order with a series of remove_min operations The running time depends on the priority queue implementation: Unsorted sequence gives selection-sort: O(n2) time Sorted sequence gives insertion-sort: O(n2) time Can we do better? Algorithm PQ-Sort(S, C) Input sequence S, comparator C for the elements of S Output sequence S sorted in increasing order according to C P  priority queue with comparator C while S.is_empty () e  S.remove_first () P.add (e, ) while P.is_empty() e  P.removeMin().key() S.add_last(e)

Heap-Sort Performance Consider a priority queue with n items implemented by means of a heap the space used is O(n) methods add and remove_min take O(log n) time methods len, is_empty, and min take time O(1) time Using a heap-based priority queue, we can sort a sequence of n elements in O(n log n) time The resulting algorithm is called heap-sort Heap-sort is much faster than quadratic sorting algorithms, such as insertion-sort and selection-sort

9.5 Adaptable Priority Queues 3 a 5 g 4 e 9.5.1 Locators 9.5.2 Implementing an Adaptable Priority Queue

Items and Priority Queues Locators 9/12/2018 3:26 PM Items and Priority Queues An item stores a (key, value) pair Item fields: _key: the key associated with this item _value: the value paired with the key associated with this item Priority Queue ADT: add(k, x) inserts an item with key k and value x remove_min() removes and returns the item with smallest key min() returns, but does not remove, an item with smallest key len(P), is_empty()

E.g.: Standby airline passenger application A standby passenger with a pessimistic attitude may become tired of waiting and decide to leave ahead of the boarding time Operation remove min does not suffice since the passenger leaving does not necessarily have first priority. Instead, we want a new operation, remove, that removes an arbitrary entry. Another standby passenger finds her gold frequent-flyer card and shows it to the agent Thus, her priority has to be modified accordingly. To achieve this change of priority, we would like to have a new operation update allowing us to replace the key of an existing entry with a new key.

Locators 9/12/2018 3:26 PM Example Online trading system where orders to purchase and sell a stock are stored in two priority queues (one for sell orders and one for buy orders) as (p,s) entries: The key, p, of an order is the price The value, s, for an entry is the number of shares A buy order (p,s) is executed when a sell order (p’,s’) with price p’<p is added (the execution is complete if s’>s) A sell order (p,s) is executed when a buy order (p’,s’) with price p’>p is added (the execution is complete if s’>s) What if someone wishes to cancel their order before it executes? What if someone wishes to update the price or number of shares for their order?

Methods of the Adaptable Priority Queue ADT P.remove(loc): Remove from P and return item e for locator loc. P.update(loc,k,v): Replace the key-value pair for locator, loc, with (k,v). In order to implement methods update and remove efficiently, we need a mechanism for finding a user’s element within a priority queue that avoids performing a linear search through the entire collection. To support our goal, when a new element is added to the priority queue, we return a special object known as a locator to the caller. We then require the user to provide an appropriate locator as a parameter when invoking the update or remove method, as follows, for a priority queue P: Adaptable 英 [ əˈdæptəbl ] 美 [ əˈdæptəbəl ]   adj.可适应的; 有适应能力的; 适合的; 可改编的

Locators 9/12/2018 3:26 PM Locators A locator-aware item identifies and tracks the location of its (key, value) object within a data structure Intuitive notion: Coat claim check Valet claim ticket Reservation number Main idea: Since items are created and returned from the data structure itself, it can return location-aware items, thereby making future updates easier locator 英 [ ləʊˈkeɪtə(r) ] 美 [ loʊˈkeɪtər ] n.表示位置之物,土地 Coat claim check 外套要求检查  Valet claim ticket 代客索票 

List Implementation A location-aware list item is an object storing key value position (or rank) of the item in the list In turn, the position (or array cell) stores the entry Back pointers (or ranks) are updated during swaps trailer header nodes/positions in turn 英 [ in tə:n ] 美 [ ɪn tɚn ] 释义依次; 轮流地; 相应地; 转而 2 c 4 c 5 c 8 c items

Heap Implementation A location-aware heap item is an object storing key value position of the item in the underlying heap In turn, each heap position stores an item Back pointers are updated during item swaps 4 a 2 d 6 b 8 g 5 e 9 c

Performance Improved times thanks to location-aware items are highlighted in red Method Unsorted List Sorted List Heap len, is_empty O(1) O(1) O(1) add O(1) O(n) O(log n) min O(n) O(1) O(1) remove_min O(n) O(1) O(log n) remove O(1) O(1) O(log n) update O(1) O(n) O(log n)

Summary