# Binary Heap using Python

A Binary Heap is a Binary Tree with following properties.

1. It’s a complete tree (All levels are completely filled except possibly the last level and the last level has all keys as left as possible). This property of Binary Heap makes them suitable to be stored in an array.
2. A Binary Heap is either Min Heap or Max Heap. In a Min Binary Heap, the key at root must be minimum among all keys present in Binary Heap. The same property must be recursively true for all nodes in Binary Tree. Max Binary Heap is similar to MinHeap.

How is Binary Heap represented?
A Binary Heap is a Complete Binary Tree. A binary heap is typically represented as an array.

• The root element will be at Arr.
• Below table shows indexes of other nodes for the ith node, i.e., Arr[i]:
Arr[(i-1)/2] Returns the parent node
Arr[(2*i)+1] Returns the left child node
Arr[(2*i)+2] Returns the right child node

The traversal method use to achieve Array representation is Level Order

Operations on Min Heap:
1) getMini(): It returns the root element of Min Heap. Time Complexity of this operation is O(1).

2) extractMin(): Removes the minimum element from MinHeap. Time Complexity of this Operation is O(Logn) as this operation needs to maintain the heap property (by calling heapify()) after removing root.

3) decreaseKey(): Decreases value of key. The time complexity of this operation is O(Logn). If the decreases key value of a node is greater than the parent of the node, then we don’t need to do anything. Otherwise, we need to traverse up to fix the violated heap property.

4) insert(): Inserting a new key takes O(Logn) time. We add a new key at the end of the tree. IF new key is greater than its parent, then we don’t need to do anything. Otherwise, we need to traverse up to fix the violated heap property.

5) delete(): Deleting a key also takes O(Logn) time. We replace the key to be deleted with minum infinite by calling decreaseKey(). After decreaseKey(), the minus infinite value must reach root, so we call extractMin() to remove the key.

Below is the implementation of basic heap operations.

`# A Python program to demonstrate common binary heap operations`

` `

`# Import the heap functions from python library`

`from` `heapq ` `import` `heappush, heappop, heapify `

` `

`# heappop - pop and return the smallest element from heap`

`# heappush - push the value item onto the heap, maintaining`

`# heap invarient`

`# heapify - transform list into heap, in place, in linear time`

` `

`# A class for Min Heap`

`class` `MinHeap:`

` `

` ` `# Constructor to initialize a heap`

` ` `def` `__init__(` `self` `):`

` ` `self` `.heap ` `=` `[] `

` `

` ` `def` `parent(` `self` `, i):`

` ` `return` `(i` `-` `1` `)` `/` `2`

` `

` ` `# Inserts a new key 'k'`

` ` `def` `insertKey(` `self` `, k):`

` ` `heappush(` `self` `.heap, k) `

` `

` ` `# Decrease value of key at index 'i' to new_val`

` ` `# It is assumed that new_val is smaller than heap[i]`

` ` `def` `decreaseKey(` `self` `, i, new_val):`

` ` `self` `.heap[i] ` `=` `new_val `

` ` `while` `(i !` `=` `0` `and` `self` `.heap[` `self` `.parent(i)] > ` `self` `.heap[i]):`

` ` `# Swap heap[i] with heap[parent(i)]`

` ` `self` `.heap[i] , ` `self` `.heap[` `self` `.parent(i)] ` `=` `(`

` ` `self` `.heap[` `self` `.parent(i)], ` `self` `.heap[i])`

` `

` ` `# Method to remove minium element from min heap`

` ` `def` `extractMin(` `self` `):`

` ` `return` `heappop(` `self` `.heap)`

` `

` ` `# This functon deletes key at index i. It first reduces`

` ` `# value to minus infinite and then calls extractMin()`

` ` `def` `deleteKey(` `self` `, i):`

` ` `self` `.decreaseKey(i, ` `float` `(` `"-inf"` `))`

` ` `self` `.extractMin()`

` `

` ` `# Get the minimum element from the heap`

` ` `def` `getMin(` `self` `):`

` ` `return` `self` `.heap[` `0` `]`

` `

`# Driver pgoratm to test above function`

`heapObj ` `=` `MinHeap()`

`heapObj.insertKey(` `3` `)`

`heapObj.insertKey(` `2` `)`

`heapObj.deleteKey(` `1` `)`

`heapObj.insertKey(` `15` `)`

`heapObj.insertKey(` `5` `)`

`heapObj.insertKey(` `4` `)`

`heapObj.insertKey(` `45` `)`

` `

`print` `heapObj.extractMin(),`

`print` `heapObj.getMin(),`

`heapObj.decreaseKey(` `2` `, ` `1` `)`

`print` `heapObj.getMin()`

` `

`

Output:

2 4 1