- Design and Analysis of Algorithms
- Home
- Basics of Algorithms
- DAA - Introduction
- DAA - Analysis of Algorithms
- DAA - Methodology of Analysis
- Asymptotic Notations & Apriori Analysis
- Time Complexity
- Master’s Theorem
- DAA - Space Complexities
- Divide & Conquer
- DAA - Divide & Conquer
- DAA - Max-Min Problem
- DAA - Merge Sort
- DAA - Binary Search
- Strassen’s Matrix Multiplication
- Karatsuba Algorithm
- Towers of Hanoi
- Greedy Algorithms
- DAA - Greedy Method
- Travelling Salesman Problem
- Prim's Minimal Spanning Tree
- Kruskal’s Minimal Spanning Tree
- Dijkstra’s Shortest Path Algorithm
- Map Colouring Algorithm
- DAA - Fractional Knapsack
- DAA - Job Sequencing with Deadline
- DAA - Optimal Merge Pattern
- Dynamic Programming
- DAA - Dynamic Programming
- Matrix Chain Multiplication
- Floyd Warshall Algorithm
- DAA - 0-1 Knapsack
- Longest Common Subsequence
- Travelling Salesman Problem | Dynamic Programming
- Randomized Algorithms
- Randomized Algorithms
- Randomized Quick Sort
- Karger’s Minimum Cut
- Fisher-Yates Shuffle
- Approximation Algorithms
- Approximation Algorithms
- Vertex Cover Problem
- Set Cover Problem
- Travelling Salesperson Approximation Algorithm
- Graph Theory
- DAA - Spanning Tree
- DAA - Shortest Paths
- DAA - Multistage Graph
- Optimal Cost Binary Search Trees
- Heap Algorithms
- DAA - Binary Heap
- DAA - Insert Method
- DAA - Heapify Method
- DAA - Extract Method
- Sorting Techniques
- DAA - Bubble Sort
- DAA - Insertion Sort
- DAA - Selection Sort
- DAA - Shell Sort
- DAA - Heap Sort
- DAA - Bucket Sort
- DAA - Counting Sort
- DAA - Radix Sort
- Searching Techniques
- Searching Techniques Introduction
- DAA - Linear Search
- DAA - Binary Search
- DAA - Interpolation Search
- DAA - Jump Search
- DAA - Exponential Search
- DAA - Fibonacci Search
- DAA - Sublist Search
- Complexity Theory
- Deterministic vs. Nondeterministic Computations
- DAA - Max Cliques
- DAA - Vertex Cover
- DAA - P and NP Class
- DAA - Cook’s Theorem
- NP Hard & NP-Complete Classes
- DAA - Hill Climbing Algorithm
- DAA Useful Resources
- DAA - Quick Guide
- DAA - Useful Resources
- DAA - Discussion

# Design and Analysis Binary Heap

There are several types of heaps, however in this chapter, we are going to discuss binary heap. A **binary heap** is a data structure, which looks similar to a complete binary tree. Heap data structure obeys ordering properties discussed below. Generally, a Heap is represented by an array. In this chapter, we are representing a heap by ** H**.

As the elements of a heap is stored in an array, considering the starting index as ** 1**, the position of the parent node of

**i**element can be found at

^{th}**. Left child and right child of**

*⌊ i/2 ⌋***i**node is at position

^{th}**and**

*2i***.**

*2i + 1*A binary heap can be classified further as either a ** max-heap** or a

**based on the ordering property.**

*min-heap*## Max-Heap

In this heap, the key value of a node is greater than or equal to the key value of the highest child.

Hence, *H[Parent(i)] ≥ H[i]*

## Min-Heap

In mean-heap, the key value of a node is lesser than or equal to the key value of the lowest child.

Hence, *H[Parent(i)] ≤ H[i]*

In this context, basic operations are shown below with respect to Max-Heap. Insertion and deletion of elements in and from heaps need rearrangement of elements. Hence, **Heapify** function needs to be called.

## Array Representation

A complete binary tree can be represented by an array, storing its elements using level order traversal.

Let us consider a heap (as shown below) which will be represented by an array **H**.

Considering the starting index as **0**, using level order traversal, the elements are being kept in an array as follows.

Index |
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | ... |

elements |
70 | 30 | 50 | 12 | 20 | 35 | 25 | 4 | 8 | ... |

In this context, operations on heap are being represented with respect to Max-Heap.

To find the index of the parent of an element at index **i**, the following algorithm ** Parent (numbers[], i)** is used.

Algorithm: Parent (numbers[], i)if i == 1 return NULL else [i / 2]

The index of the left child of an element at index **i** can be found using the following algorithm, ** Left-Child (numbers[], i)**.

Algorithm: Left-Child (numbers[], i)If 2 * i ≤ heapsize return [2 * i] else return NULL

The index of the right child of an element at index **i** can be found using the following algorithm, ** Right-Child(numbers[], i)**.

Algorithm: Right-Child (numbers[], i)if 2 * i < heapsize return [2 * i + 1] else return NULL