What is a heap? Always keep the thing we are most interested in close to the top (and fast to access). Like a binary search tree, but less structured.

Slides:



Advertisements
Similar presentations
Analysis of Algorithms
Advertisements

David Luebke 1 5/20/2015 CS 332: Algorithms Quicksort.
Comp 122, Spring 2004 Heapsort. heapsort - 2 Lin / Devi Comp 122 Heapsort  Combines the better attributes of merge sort and insertion sort. »Like merge.
Data Structures, Spring 2004 © L. Joskowicz 1 Data Structures – LECTURE 7 Heapsort and priority queues Motivation Heaps Building and maintaining heaps.
David Luebke 1 7/2/2015 Merge Sort Solving Recurrences The Master Theorem.
PQ, binary heaps G.Kamberova, Algorithms Priority Queue ADT Binary Heaps Gerda Kamberova Department of Computer Science Hofstra University.
2IL50 Data Structures Spring 2015 Lecture 3: Heaps.
David Luebke 1 10/3/2015 CS 332: Algorithms Solving Recurrences Continued The Master Theorem Introduction to heapsort.
The Binary Heap. Binary Heap Looks similar to a binary search tree BUT all the values stored in the subtree rooted at a node are greater than or equal.
2IL50 Data Structures Fall 2015 Lecture 3: Heaps.
Heaps. What is a heap? Like a binary search tree, but less structure within each level. Guarantees: – Parent better than child – That’s it! What does.
David Luebke 1 6/3/2016 CS 332: Algorithms Heapsort Priority Queues Quicksort.
Data Structure & Algorithm II.  In a multiuser computer system, multiple users submit jobs to run on a single processor.  We assume that the time required.
Priority Queues and Heaps. October 2004John Edgar2  A queue should implement at least the first two of these operations:  insert – insert item at the.
CS 2133: Data Structures Quicksort. Review: Heaps l A heap is a “complete” binary tree, usually represented as an array:
What is a heap? Always keep the thing we are most interested in close to the top (and fast to access). Like a binary search tree, but less structured.
1 Analysis of Algorithms Chapter - 03 Sorting Algorithms.
David Luebke 1 12/23/2015 Heaps & Priority Queues.
Computer Algorithms Lecture 9 Heapsort Ch. 6, App. B.5 Some of these slides are courtesy of D. Plaisted et al, UNC and M. Nicolescu, UNR.
S. Raskhodnikova and A. Smith. Based on slides by C. Leiserson and E. Demaine. 1 Adam Smith L ECTURES Priority Queues and Binary Heaps Algorithms.
CSC 413/513: Intro to Algorithms Solving Recurrences Continued The Master Theorem Introduction to heapsort.
Chapter 6: Heapsort Combines the good qualities of insertion sort (sort in place) and merge sort (speed) Based on a data structure called a “binary heap”
Lecture 8 : Priority Queue Bong-Soo Sohn Assistant Professor School of Computer Science and Engineering Chung-Ang University.
1 Heap Sort. A Heap is a Binary Tree Height of tree = longest path from root to leaf =  (lgn) A heap is a binary tree satisfying the heap condition:
David Luebke 1 2/5/2016 CS 332: Algorithms Introduction to heapsort.
Sept Heapsort What is a heap? Max-heap? Min-heap? Maintenance of Max-heaps -MaxHeapify -BuildMaxHeap Heapsort -Heapsort -Analysis Priority queues.
Priority Queues and Heaps. John Edgar  Define the ADT priority queue  Define the partially ordered property  Define a heap  Implement a heap using.
Priority Queues A priority queue is an ADT where:
"Teachers open the door, but you must enter by yourself. "
Partially Ordered Data ,Heap,Binary Heap
Lecture: Priority Queue
DAST Tirgul 7.
Heaps (8.3) CSE 2011 Winter May 2018.
CSCE 210 Data Structures and Algorithms
Heaps, Heapsort, and Priority Queues
Priority Queues and Heaps
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,
October 30th – Priority QUeues
Heaps © 2010 Goodrich, Tamassia Heaps Heaps
Bohyung Han CSE, POSTECH
Heaps 9/13/2018 3:17 PM Heaps Heaps.
Heap Sort Example Qamar Abbas.
Introduction to Algorithms
ADT Heap data structure
7/23/2009 Many thanks to David Sun for some of the included slides!
Priority Queue & Heap CSCI 3110 Nan Chen.
Part-D1 Priority Queues
Priority Queues.
Heaps, Heapsort, and Priority Queues
Ch 6: Heapsort Ming-Te Chi
Heaps 11/27/ :05 PM Heaps Heaps.
B-Tree Insertions, Intro to Heaps
Data Structures and Algorithms (AT70. 02) Comp. Sc. and Inf. Mgmt
Priority Queues.
Heapsort.
ITEC 2620M Introduction to Data Structures
© 2013 Goodrich, Tamassia, Goldwasser
Ch. 8 Priority Queues And Heaps
Hassan Khosravi / Geoffrey Tien
"Teachers open the door, but you must enter by yourself. "
Heaps © 2014 Goodrich, Tamassia, Goldwasser Heaps Heaps
Data Structures Lecture 29 Sohail Aslam.
Topic 5: Heap data structure heap sort Priority queue
HEAPS.
Heapsort Sorting in place
Solving Recurrences Continued The Master Theorem
Computer Algorithms CISC4080 CIS, Fordham Univ.
Priority Queues Binary Heaps
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.
CMPT 225 Lecture 16 – Heap Sort.
Presentation transcript:

What is a heap? Always keep the thing we are most interested in close to the top (and fast to access). Like a binary search tree, but less structured. No relationship between keys at the same level (unlike BST).

Types of heaps Min heap: priority 1 more important than 100 Max heap: 100 more important than 1 We are going to talk about max heaps. Max heap-order property Look at any node u, and its parent p. p.priority ≥ u.priority p:7 u:3

Abstract data type (ADT) We are going to use max-heaps to implement the (max) priority queue ADT A priority queue Q offers (at least) 2 operations: Extract-max(Q): returns the highest priority element Insert(Q, e): inserts e into Q Every time an Insert or Extract-max changes the heap, it must restore the max-heap order property. ( Prove by induction on the sequence of inserts and extract-maxes that occur.) Heaps are faster! =D

What can we do with a heap Can do same stuff with a BST… why use a heap? BST extract-max is O(depth); heap is O(log n)! When would we use a BST? When we need to search for a particular key.

Storing a heap in memory Heaps are typically implemented with arrays. The array is just a level-order traversal of the heap. The children of the node at index i are at 2i and 2i+1.

Example time Interactive heap visualization Insert places a key in a new node that is the last node in a level-order-traversal of the heap. The inserted key is then “bubbled” upwards until the heap property is satisfied. Extract-max removes the last node in a level-order-traversal and moves its key into the root. The new key at the root is then bubbled down until the heap property is satisfied. Bubbling down is also called heapifying.

Building a max-heap in O(n) time Suppose we want to build a heap from an unsorted array: 10, 2, 7, 8, 6, 5, 9, 4, 3, 11. We start by interpreting the array as a tree.

Building a heap: a helper function Precondition: trees rooted at L and R are heaps Postcondition: tree rooted at I is a heap MaxHeapify(A,I): L = LEFT(I) R = RIGHT(I) If L ≤ heap_size(A) and A[L] > A[I] then max = L else max = I If R ≤ heap_size(A) and A[R] > A[max] then max = R If max is L or R then swap(A[I],A[max]) MaxHeapify(A,max) Case 1: max = L Need to fix… L:7 R:5 I:7 Case 2: max = I Heap OK! L:3 R:5 Sketch the code, then walk them through the cases, then discuss the precondition and postcondition, then show them how, e.g., case three works (meaning the postcondition is satisfied if the precondition is satisfied). I:5 Case 3: max = R Need to fix… L:3 R:7

Proving MaxHeapify is correct How would you formally prove that MaxHeapify is correct? Goal: Prove MaxHeapify is correct for all inputs. “Correct” means: “if the precondition is satisfied when MaxHeapify is called, then the postcondition will be satisfied when it finishes.” How do we prove a recursive function correct? Define a problem size, and prove correctness by induction on problem size. Base case: show function is correct for any input of the smallest problem size. Inductive step: assume function is correct for problem size j; show it is correct for problem size j+1.

Proving MaxHeapify is correct - 2 Let’s apply this to MaxHeapify. Problem size: height of node I. Base case: Prove MaxHeapify is correct for every input with height(I) = 0. Inductive step: Let A and I be any input parameters that satisfy the precondition. Assume MaxHeapify is correct when the problem size is j. Prove MaxHeapify is correct when the problem size is j+1.

Proving MaxHeapify is correct - 3 Precondition: trees rooted at L and R are heaps Postcondition: tree rooted at I is a heap MaxHeapify(A,I): L = LEFT(I) R = RIGHT(I) If L ≤ heap_size(A) and A[L] > A[I] then max = L else max = I If R ≤ heap_size(A) and A[R] > A[max] then max = R If max is L or R then swap(A[I],A[max]) MaxHeapify(A,max) Case 1: max = L Need to fix… L:7 R:5 I:7 Case 2: max = I Heap OK! L:3 R:5 Base case: j = 0. Any node with height 0 is a heap, so the post condition is satisfied. Inductive step: Assume MaxHeapify is correct when its input I has height j. Show it is correct when I has height j+1. Explain case 3 as an example. I:5 Case 3: max = R Need to fix… L:3 R:7

The main function BUILD-MAX-HEAP(A): for i = heap_size(A)/2 down to 1 MaxHeapify(A,i) Why do we iterate from heap_size(A)/2 and not from heap_size(A)? Why do we iterate backwards? (What do we know about the nodes from heap_size(A)/2 down to 1? Is there any point in calling max heapify on any of the other nodes?) We need to know that max heapify’s precondition is satisfied, in order for us to call it… Show how, this way, the precondition is satisfied, so the postcondition guarantees that we are always building larger and larger heaps, as we move up.

Analyzing worst-case complexity  

Analyzing worst-case complexity  

≤ 2d nodes at depth d Node at depth d has height ≤ h-d   ≤ 2d nodes at depth d Node at depth d has height ≤ h-d Cost to “heapify” one node at depth d is ≤ c(h-d) Don’t care about constants... Ignoring them below… Cost to heapify all nodes at depth d is ≤ 2d (h-d)

  So, cost to heapify all nodes over all depths is: