Priority Queues.

Slides:



Advertisements
Similar presentations
Priority Queues. 2 Priority queue A stack is first in, last out A queue is first in, first out A priority queue is least-first-out The “smallest” element.
Advertisements

CHAPTER 5 PRIORITY QUEUES (HEAPS) §1 ADT Model Objects: A finite ordered list with zero or more elements. Operations:  PriorityQueue Initialize( int.
Priority Queues. Container of elements where each element has an associated key A key is an attribute that can identify rank or weight of an element Examples.
Heapsort. 2 Why study Heapsort? It is a well-known, traditional sorting algorithm you will be expected to know Heapsort is always O(n log n) Quicksort.
Version TCSS 342, Winter 2006 Lecture Notes Priority Queues Heaps.
Priority Queues. Priority queue A stack is first in, last out A queue is first in, first out A priority queue is least-first-out –The “smallest” element.
Priority Queues. Priority queue A stack is first in, last out A queue is first in, first out A priority queue is least-first-out –The “smallest” element.
1 CS211, Lecture 20 Priority queues and Heaps Readings: Weiss, sec. 6.9, secs When they've got two queues going, there's never any queue!
Priority Queues. Container of elements where each element has an associated key A key is an attribute that can identify rank or weight of an element Examples.
Source: Muangsin / Weiss1 Priority Queue (Heap) A kind of queue Dequeue gets element with the highest priority Priority is based on a comparable value.
CSC 172 DATA STRUCTURES. Priority Queues Model Set with priorities associatedwith elements Priorities are comparable by a < operator Operations Insert.
Heapsort Based off slides by: David Matuszek
1 HEAPS & PRIORITY QUEUES Array and Tree implementations.
Geoff Holmes and Bernhard Pfahringer COMP206-08S General Programming 2.
1 Hash Tables  a hash table is an array of size Tsize  has index positions 0.. Tsize-1  two types of hash tables  open hash table  array element type.
ADT Table and Heap Ellen Walker CPSC 201 Data Structures Hiram College.
Heapsort CSC Why study Heapsort? It is a well-known, traditional sorting algorithm you will be expected to know Heapsort is always O(n log n)
Priority Queues and Binary Heaps Chapter Trees Some animals are more equal than others A queue is a FIFO data structure the first element.
1 Heaps and Priority Queues Starring: Min Heap Co-Starring: Max Heap.
Priority Queues Dr. David Matuszek
1 Heaps and Priority Queues v2 Starring: Min Heap Co-Starring: Max Heap.
Queues, Stacks and Heaps. Queue List structure using the FIFO process Nodes are removed form the front and added to the back ABDC FrontBack.
Week 13 - Friday.  What did we talk about last time?  Sorting  Insertion sort  Merge sort  Started quicksort.
Chapter 13 Priority Queues. 2 Priority queue A stack is first in, last out A queue is first in, first out A priority queue is least-in-first-out The “smallest”
HEAPS. Review: what are the requirements of the abstract data type: priority queue? Quick removal of item with highest priority (highest or lowest key.
CS 367 Introduction to Data Structures Lecture 8.
Priority Queues CS 110: Data Structures and Algorithms First Semester,
Week 13 - Wednesday.  What did we talk about last time?  NP-completeness.
1 Priority Queues (Heaps). 2 Priority Queues Many applications require that we process records with keys in order, but not necessarily in full sorted.
Priority Queues and Heaps Tom Przybylinski. Maps ● We have (key,value) pairs, called entries ● We want to store and find/remove arbitrary entries (random.
CS 201 Data Structures and Algorithms
Heaps (8.3) CSE 2011 Winter May 2018.
Priority Queues and Heaps
Lecture 15 AVL Trees Slides modified from © 2010 Goodrich, Tamassia & by Prof. Naveen Garg’s Lectures.
October 30th – Priority QUeues
Source: Muangsin / Weiss
Bohyung Han CSE, POSTECH
Heap Sort Example Qamar Abbas.
Chapter 22 : Binary Trees, AVL Trees, and Priority Queues
Map interface Empty() - return true if the map is empty; else return false Size() - return the number of elements in the map Find(key) - if there is an.
original list {67, 33,49, 21, 25, 94} pass { } {67 94}
CMSC 341: Data Structures Priority Queues – Binary Heaps
Binary Heaps Text Binary Heap Building a Binary Heap
Data Structures & Algorithms Priority Queues & HeapSort
Priority Queues.
Dr. David Matuszek Heapsort Dr. David Matuszek
CSE 373: Data Structures and Algorithms
Binary Tree Application Operations in Heaps
Priority Queues.
Priority Queues.
CS Data Structures Chapter 17 Heaps Mehmet H Gunes
Computer Science 2 Heaps.
CE 221 Data Structures and Algorithms
Binary Heaps What if we’re mostly concerned with finding the most relevant data? A binary heap is a binary tree (2 or fewer subtrees for each node) A heap.
Heapsort.
Copyright ©2012 by Pearson Education, Inc. All rights reserved
Heaps © 2014 Goodrich, Tamassia, Goldwasser Heaps Heaps
A Heap Implementation Chapter 26 Adapted from Pearson Education, Inc.
Priority Queues & Heaps
Priority Queues.
Heapsort.
CSE 373, Copyright S. Tanimoto, 2002 Priority Queues -
Heaps By JJ Shepherd.
Chapter 12 Heap ADT © 2011 Pearson Addison-Wesley. All rights reserved.
Heapsort.
Chapter 9 The Priority Queue ADT
Heapsort.
CO 303 Algorithm Analysis and Design
The Heap ADT A heap is a complete binary tree where each node’s datum is greater than or equal to the data of all of the nodes in the left and right.
Heaps.
Presentation transcript:

Priority Queues

Priority queue A stack is first in, last out A queue is first in, first out A priority queue is least-first-out The “smallest” element is the first one removed (You could also define a largest-first-out priority queue) The definition of “smallest” is up to the programmer (for example, you might define it by implementing Comparator or Comparable) If there are several “smallest” elements, the implementer must decide which to remove first Remove any “smallest” element (don’t care which) Remove the first one added

A priority queue ADT Here is one possible ADT: PriorityQueue(): a constructor void add(Comparable o): inserts o into the priority queue Comparable removeLeast(): removes and returns the least element Comparable getLeast(): returns (but does not remove) the least element boolean isEmpty(): returns true iff empty int size(): returns the number of elements void clear(): discards all elements

Evaluating implementations When we choose a data structure, it is important to look at usage patterns If we load an array once and do thousands of searches on it, we want to make searching fast—so we would probably sort the array If we load a huge array and expect to do only a few searches, we probably don’t want to spend time sorting the array For almost all uses of a queue (including a priority queue), we eventually remove everything that we add Hence, when we analyze a priority queue, neither “add” nor “remove” is more important—we need to look at the timing for “add + remove”

Array implementations A priority queue could be implemented as an unsorted array (with a count of elements) Adding an element would take O(1) time (why?) Removing an element would take O(n) time (why?) Hence, adding and removing an element takes O(n) time This is an inefficient representation A priority queue could be implemented as a sorted array (again, with a count of elements) Adding an element would take O(n) time (why?) Removing an element would take O(1) time (why?) Again, this is inefficient

Linked list implementations A priority queue could be implemented as an unsorted linked list Adding an element would take O(1) time (why?) Removing an element would take O(n) time (why?) A priority queue could be implemented as a sorted linked list Adding an element would take O(n) time (why?) Removing an element would take O(1) time (why?) As with array representations, adding and removing an element takes O(n) time Again, these are inefficient implementations

Binary tree implementations A priority queue could be represented as a (not necessarily balanced) binary search tree Insertion times would range from O(log n) to O(n) (why?) Removal times would range from O(log n) to O(n) (why?) A priority queue could be represented as a balanced binary search tree Insertion and removal could destroy the balance We need an algorithm to rebalance the binary tree Good rebalancing algorithms require only O(log n) time, but are complicated

Heap implementation A priority queue can be implemented as a heap In order to do this, we have to define the heap property In Heapsort, a node has the heap property if it is at least as large as its children For a priority queue, we will define a node to have the heap property if it is as least as small as its children (since we are using smaller numbers to represent higher priorities) 12 8 3 Heapsort: Blue node has the heap property 3 8 12 Priority queue: Blue node has the heap property

Array representation of a heap 12 14 18 6 8 3 3 12 6 18 14 8 0 1 2 3 4 5 6 7 8 9 10 11 12 lastIndex = 5 Left child of node i is 2*i + 1, right child is 2*i + 2 Unless the computation yields a value larger than lastIndex, in which case there is no such child Parent of node i is (i – 1)/2 Unless i == 0

Using the heap To add an element: To remove an element: Increase lastIndex and put the new value there Reheap the newly added node This is called up-heap bubbling or percolating up Up-heap bubbling requires O(log n) time To remove an element: Remove the element at location 0 Move the element at location lastIndex to location 0, and decrement lastIndex Reheap the new root node (the one now at location 0) This is called down-heap bubbling or percolating down Down-heap bubbling requires O(log n) time Thus, it requires O(log n) time to add and remove an element

Comments A priority queue is a data structure that is designed to return elements in order of priority Efficiency is usually measured as the sum of the time it takes to add and to remove an element Simple implementations take O(n) time A heap implementation takes O(log n) time Thus, for any sort of heavy-duty use, a heap implementation is better My recommendation: If you need a priority queue, define it as an ADT Start with a simple implementation Keep the implementation hidden so you can change it later

The End