958 views

Uploaded by firefoxextslurper

- Gate 2016 Question & Keys Set 5
- How Excel Works From Data Structures Point of View
- LEC1-B.PDF
- Cs1201 Design and Analysis of Algorithm
- Useful Algorithms And Programming Technique
- Sorting 1
- DS Assignment (2)
- Testing in C
- cs1927 15s2 - wk10_tut
- Lec2
- fins11sol
- 5-Lecture 11 - Heap - Single
- DS Tutorial
- Sorting
- 05 Heaps
- Stack Queue
- btree1
- wdec
- Concurrent Data Structures
- info_iec81346-1{ed1.0}b

You are on page 1of 17

1. It is a complete binary tree; that is, each level of the tree is completely filled, except possibly

the bottom level. At this level, it is filled from left to right.

2. It satisfies the heap-order property: The data item stored in each node is greater

than or equal to the data items stored in its children.

• Examples:

(a) (b) (c)

9 9 9

8 4 8 4 6 4

6 2 3 6 2 3 8 2 3

• In the above examples only (a) is a heap. (b) is not a heap as it is not complete and (c) is complete

but does not satisfy the second property defined for heaps.

Heap as an Array

• We could implement heaps using a linked list like structure, like we did with

binary trees but in this instance it is actually easier to implement heaps using

arrays.

• We simply number the nodes in the heap from top to bottom, numbering the nodes

on each level from left to right and store the ith node in the ith location of the

array. (of course remembering that array indexing in Java starts at zero).

1

2 3

4 5 6 7

Heap as an Array (2)

• An array A that represents a heap is an array with two attributes

– length, the number of elements in the array

– heap-size, the number of heap elements stored in the array

• Viewed as a binary tree and as an array :

1

16

2 3

14 10

4 5 6 7

8 7 9 3

8 9 10

2 4 1

1 2 3 4 5 6 7 8 9 10

16 14 10 8 7 9 3 2 4 1

• The root of the tree is stored at A[0], its left-child at A[1], its right child at A[2]

etc.

Programming and Data Structures 3

Accessing the Heap Values

• Given the index i of a node, the indices of its parent Parent(i), left-child

LeftChild(i) and right child RightChild(i) can be computed simply :

return i/2 return 2i return 2i+1

• Heaps must also satisfy the heap property for every node, i, other than the

root.

A[Parent(i)] ≥ A[i]

• Therefore, the largest element in a heap is stored at the root, and the

subtrees rooted at a node contain smaller values than does the node itself.

Heap Operations

• The height of a node in a tree is the number of

edges on the longest simple downward path from

the node to a leaf. (i.e. maximum depth from that

node – Remember?)

binary tree is lg n

most proportional to the height of the tree and

thus take O(lg n) time.

Programming and Data Structures 5

Maintaining the Heap Property

• One of the more basic heap operations is converting a complete binary

tree to a heap.

LeftChild(i) and RightChild(i) are heaps, but that A[i] may be smaller

than its children, thus violating the 2nd heap property.

• The function of Heapify is to let the value at A[i] “float down” in the

heap so that the subtree rooted at index i becomes a heap.

Programming and Data Structures 6

Example of Heapify

1

16 • Subtree to be heapified is marked by the shaded

2 3

i 4 5 10 7

triangle.

4 6

14 7 9 3 • Node i if smaller than its children is swapped with

8 9 10 the greater of its two children – in this case the left

2 8 1 child with value 14 is swapped for value 4 in node I.

1

16 • If the next subtree down (again marked with the

2 3

14 10 shaded triangle region) is not a heap, we “percolate”

4 5 6 7 down to the next subtree level and find the larger

i 4 7 9 3 of the two children again to swap with current root

8 9 10 node.

2 8 1

1

16 • We keep “percolating” down until either the

2 3

14 10 subtree conforms to the heap properties or a leaf

4 5 6 7 has been reached.

8 7 9 3

8 9 10

2 4 1

Programming and Data Structures 7

The Heapify Algorithm

Begin

Heapify(A[], i) // Heapify takes in our heap and index of current root node of subtree to be heapified

{

left = LeftChild(i); // index of left child

right = RightChild(i); // index of right child

if left ≤ A.heap-size AND A[left] > A[i] { // if still within bounds AND left child

largest = left; // greather than parent – remember largest as left child

}

else {

largest = i; // else parent still has largest value for now

}

if right ≤ A.heap-size AND A[right] > A[largest] { // if still within bounds AND right child

largest = right // greather than parent – remember largest as right child

}

if largest NOT EQUAL i { // if parent does not hold largest value

swap A[i] and A[largest] // swap parent with child that does have largest value

Heapify(A, largest) // Percolate down and Heapify next subtree

}

}

End

The Heapify Algorithm

• At each step, the index of the largest of the elements A[i], A[Left(i)],

and A[Right(i)] is stored in the variable largest.

• If A[i] is largest, then the subtree rooted at node i is a heap and the

procedure ends.

• Otherwise, one of the two children has the largest element, and A[i] is

swapped with A[largest], which causes node i and its children to satisfy

the heap property.

• The node largest, however, now has the original value A[i], and thus

the subtree rooted at largest may violate the heap property.

Analysis of Heapify

• The running time of Heapify on a subtree of size n rooted at a given

node i is the O(1) time to fix up the relationships among the elements

A[i], A[Left(i)] and A[Right(i)], plus the time to run Heapify on a

subtree rooted at one of the children of node i.

• The subtrees can have size of at most 2n/3, and the running time of

Heapify can therefore be described by the recurrence,

T(n) ≤ T(2n/3) + O(1)

• Using either the iteration method or the master’s theorem we can find

that the solution to this works out as:

T(n) = O(log n)

Building a Heap

• For the general case of converting a complete binary tree to a heap, we begin at the last

node that is not a leaf, apply the “percolate down” routine to convert the subtree rooted at

this current root node to a heap.

• We then move onto the preceding node and “percolate down” that subtree.

• We continue on in this manner, working up the tree until we reach the root of the given tree.

• We use the Heapify procedure here in a bottom up manner. This means also means that to

convert an array A[1..n], where n = A.length, into a heap we can apply the same procedure

as described above.

• Now, since the subarray A[(n/2 + 1)..n] are all leaves of the tree, each is a 1-element heap.

• The procedure “Build-Heap” goes through the remaining nodes and runs Heapify on each.

• The order of processing guarantees that the subtrees rooted at children of node i are heaps

before Heapify is run at that node.

Build Heap Algorithm

Begin:

Build-Heap (A[]) { // takes in an array to be heapified

A.heap-size = A.length; // heap size is number of elements in the array

for i = A.length/2 downto 1 // starting at first subtree up to root full tree

{

Heapify(A, i); // Heapify the current subtree

}

}

End

• Each call to Heapify costs O(lg n) time, and there are O(n) such calls.

• Thus, the running time is at most O(n lg n)

• A more complex analysis, however, gives us a tighter upper bound of O(n).

• Hence, we can build a heap from an unordered array in linear time.

• Lets have a look at a visual example of this operation (have a look at the next slide).

• The current subtrees that are being worked on are marked inside a shaded triangle.

• Any swapping that goes on is marked with a thicker edge.

Example of Build Heap

A 4 1 3 2 1 6 9 1 0 1 4 8 7

1 1

4 4

2 3 2 3

1 3 1 3

4 5 6 7 4 5 6 7

2 i 16 9 10 i 2 16 9 10

8 9 10 8 9 10

14 8 7 14 8 7

(a) (b)

1 1

4 2 4

2 1 3 3

3 i

5 6 i 7 1

5 6

10

7

4 14 16 9 10 4 16 9 3

14

8 9 10 7 8 9 10 7

2 8 2 8

(c) (d)

1 1

i 4 16

3 2 3

216 10 14 10

5 6 7 5 6 7

4 7 9 3 4 8 7 9 3

14 10

8 9 10 8 9 1

2 8 1 2 4

(f)

(e)

Programming and Data Structures 13

Heap Practical Example :Priority Queue

• Many applications require that we process records with keys/priorities

in order, but not necessarily in full sorted order. (e.g. CPU process

scheduling).

into the queue

• Items can be placed on the queue at any time, but processing always

takes the item with the largest key/ priority

(ADT)

• In fact, the priority queue is a proper generalisation of the stact and the

queue ADTs, as we can implement either with priority queues, using

appropriate priorities

Programming and Data Structures 14

Priority Queue - Definition

• A priority queue is a data structure of items with keys that support two basic

operations : insert a new item, and delete the item with the largest key.

6 5 5 3 2 1

6 6 5 5 3 2 1 Add item with priority 6

6 6 5 5 4 3 2 1 Add item with priority 4

6 5 5 4 3 2 1 Remove item with highest priority

– Simulation Systems, where events need to be processed chronologically.

– Job scheduling in computer systems.

priority queue.

• In practice, priority queues are more complex than the simple definition above.

Programming and Data Structures 15

Priority Queue

• One of the reasons that priority queue implementations are so useful is

their flexibility

• For that reason any implementation will need to support some of the

following operations

– Construct a priority queue from N given items

– Insert a new item

– Delete the maximum item

– Change the priority of an arbitrary specified item

– Delete an arbitrary specified item

• We take “maximum” to mean “any record with the largest key value”.

Other Heap Operations

• Other important heap operations include :

- Heap Insert (inserting an element into a heap)

- Heap Extract Max/Min (extracting an Max/Min element from a heap)

- Heap Delete (remove an element from a heap)

- And of course…. HeapSort - O(N lg N) sorting algorithm

+ very basic idea :

* swap and remove root value with final position element value

* decrement size of heap and Heapify from position one (i.e. new root) again

to restore new heap

* Keep doing this while there is more nodes. This eventually gives us a

sorted list.

more detail.

- Gate 2016 Question & Keys Set 5Uploaded byUjjawal Maan
- How Excel Works From Data Structures Point of ViewUploaded bypandyakavi
- LEC1-B.PDFUploaded byhardnut
- Cs1201 Design and Analysis of AlgorithmUploaded byvijay_sudha
- Useful Algorithms And Programming TechniqueUploaded byRahul Jain
- Sorting 1Uploaded byDeepak Malusare
- DS Assignment (2)Uploaded byvithya
- Testing in CUploaded byTommy Lee
- cs1927 15s2 - wk10_tutUploaded byVictor
- Lec2Uploaded byPrakhar Singh Pundhir
- fins11solUploaded byAndy Lien
- 5-Lecture 11 - Heap - SingleUploaded bymuthurakkappanr
- DS TutorialUploaded bypooja0100
- SortingUploaded byjimusos
- 05 HeapsUploaded byMadeeha Ansaf
- Stack QueueUploaded bySubhransu Dalai
- btree1Uploaded bykapilkumargupta
- wdecUploaded byJeena Mathew
- Concurrent Data StructuresUploaded byAbhinav Karan
- info_iec81346-1{ed1.0}bUploaded byIranga Madushanka
- commref_mb3.2Uploaded byShaquille Benjamin
- UNIT III.docUploaded bySeshu Chakravarthy
- Binary Search TreeUploaded byShanks1
- 441 Lecture Notes PART1Uploaded bySerkan Karadağ
- RapidMiner 5.2 Advanced ChartsUploaded byeuge_prime2001
- Pertemuan 3 Decision Making Tools v 2018Uploaded byIwayan Aikyam Suyanca
- Oracle White Paper - Using Oracle Streams Advanced Queueing Best PracticesUploaded byjpaulino
- Tmp 9851Uploaded byFrontiers
- 04 LAB a Implementing Stacks & Queues - AnswersUploaded byCatherine Rosales Tio
- Dat Astruc tUploaded byChayne Rodil

- UntitledUploaded byfirefoxextslurper
- TestUploaded byfirefoxextslurper
- 6th Central Pay Commission salary calculatorUploaded byrakhonde
- 6th Central Pay Commission salary calculatorUploaded byrakhonde
- 6th Central Pay Commission salary calculatorUploaded byrakhonde
- 5 7 KET 2006 0752 1Uploaded byfirefoxextslurper
- 255 guideUploaded byfirefoxextslurper
- ChicagoUploaded byfirefoxextslurper
- v5 7746JAP FacadeUploaded byfirefoxextslurper
- Maritime-House-Greenwich-AbacusEstatesUploaded byfirefoxextslurper
- t400 and t500 DatasheetUploaded byfirefoxextslurper
- changinglondonUploaded byfirefoxextslurper
- obergrenzen2009Uploaded byfirefoxextslurper
- Chapter 1Uploaded byfirefoxextslurper
- Intro Excavators Info SheetUploaded byfirefoxextslurper
- dmAD0132Uploaded byfirefoxextslurper
- sale method fireUploaded byfirefoxextslurper
- Algorithm Design TechniquesUploaded byfirefoxextslurper
- reviewers guideUploaded byfirefoxextslurper
- Asymmetric Dekker SynchronizationUploaded byfirefoxextslurper
- 99 InliningUploaded byfirefoxextslurper
- PlayingWithTypes2Uploaded byfirefoxextslurper
- barendregt92lambdaUploaded byfirefoxextslurper
- OsrUploaded byfirefoxextslurper
- brochureUploaded byfirefoxextslurper
- v2i1r24Uploaded byfirefoxextslurper
- Synchronization Public2Uploaded byfirefoxextslurper
- ThesisUploaded byfirefoxextslurper
- brian92usingUploaded byfirefoxextslurper
- mvc templatesUploaded byfirefoxextslurper

- Target PlacementsTQuestionsUploaded bysishantkumar
- Given the Following Code SnippetUploaded bySanjay Shekhar
- Tarjan85_AmortizedComplexity.pdfUploaded bynicolas
- CS2251-QBUploaded byKishore Arun Kumar
- 942Uploaded bySayan Kumar Khan
- vit syllabaus eceUploaded byPranavateja Chilukuri
- Data Structure Questions BankUploaded bynooti
- 1-slideUploaded byfsdgfghsdg
- IT Final Upto 4th Year Syllabus 14.03.14Uploaded byBashitwa Roy
- 6.VivaUploaded byAswathy Vineeth
- DS-MCQsUploaded bydeepalikayande
- 3rd sem cseUploaded byDeepak Varshney
- M.tech_CAD_CAM_Syllabus.pdfUploaded bySurendra Saini
- Technical Interview Questions and Answers[1]Uploaded byAnonymous d6vkxJ
- DSPMUploaded byAmrendra Singh
- 06 Priority QueuesUploaded bybsgindia82
- DS LAB MANUALUploaded bykrishnakrishna22
- ADOBE Written TestUploaded bybrp700144
- Top Data Structure Interview Questions and Answers Are BelowUploaded byArchana Sinha
- multibit flipflopsUploaded bydinuarslan
- Ds ObjectiveUploaded byAnamika Chauhan Verma
- testBankCh10Uploaded byRoofus Donald
- CS-1991Uploaded byKumar Kumarr
- LISP Tutorial LectureUploaded byAdoniasCaetano
- Technical Aptitude Questions.pdfUploaded byPerumal Namasivayam
- C++ ProgramsUploaded byRaghunath2u
- Expression Tree in Data Structure PDFUploaded byAmanda
- C Questions and Answer-libreUploaded byAshik A Nezzilianz
- 40536069 Data StructuresUploaded byshalindra
- 100 TOP C PROGRAMMING Interview Questions and AnswersUploaded byVaishakh Sasikumar