Merge pull request #123 from ojas1234/master

Added Binary heap in data structures

Author: ashwek

Data Structure/Binaryheap.cpp

@@ -0,0 +1,159 @@
+// A C++ program to demonstrate common Binary Heap Operations 
+#include<iostream> 
+#include<climits> 
+using namespace std; 
+  
+// Prototype of a utility function to swap two integers 
+void swap(int *x, int *y); 
+  
+// A class for Min Heap 
+class MinHeap 
+{ 
+    int *harr; // pointer to array of elements in heap 
+    int capacity; // maximum possible size of min heap 
+    int heap_size; // Current number of elements in min heap 
+public: 
+    // Constructor 
+    MinHeap(int capacity); 
+  
+    // to heapify a subtree with the root at given index 
+    void MinHeapify(int ); 
+  
+    int parent(int i) { return (i-1)/2; } 
+  
+    // to get index of left child of node at index i 
+    int left(int i) { return (2*i + 1); } 
+  
+    // to get index of right child of node at index i 
+    int right(int i) { return (2*i + 2); } 
+  
+    // to extract the root which is the minimum element 
+    int extractMin(); 
+  
+    // Decreases key value of key at index i to new_val 
+    void decreaseKey(int i, int new_val); 
+  
+    // Returns the minimum key (key at root) from min heap 
+    int getMin() { return harr[0]; } 
+  
+    // Deletes a key stored at index i 
+    void deleteKey(int i); 
+  
+    // Inserts a new key 'k' 
+    void insertKey(int k); 
+}; 
+  
+// Constructor: Builds a heap from a given array a[] of given size 
+MinHeap::MinHeap(int cap) 
+{ 
+    heap_size = 0; 
+    capacity = cap; 
+    harr = new int[cap]; 
+} 
+  
+// Inserts a new key 'k' 
+void MinHeap::insertKey(int k) 
+{ 
+    if (heap_size == capacity) 
+    { 
+        cout << "\nOverflow: Could not insertKey\n"; 
+        return; 
+    } 
+  
+    // First insert the new key at the end 
+    heap_size++; 
+    int i = heap_size - 1; 
+    harr[i] = k; 
+  
+    // Fix the min heap property if it is violated 
+    while (i != 0 && harr[parent(i)] > harr[i]) 
+    { 
+       swap(&harr[i], &harr[parent(i)]); 
+       i = parent(i); 
+    } 
+} 
+  
+// Decreases value of key at index 'i' to new_val.  It is assumed that 
+// new_val is smaller than harr[i]. 
+void MinHeap::decreaseKey(int i, int new_val) 
+{ 
+    harr[i] = new_val; 
+    while (i != 0 && harr[parent(i)] > harr[i]) 
+    { 
+       swap(&harr[i], &harr[parent(i)]); 
+       i = parent(i); 
+    } 
+} 
+  
+// Method to remove minimum element (or root) from min heap 
+int MinHeap::extractMin() 
+{ 
+    if (heap_size <= 0) 
+        return INT_MAX; 
+    if (heap_size == 1) 
+    { 
+        heap_size--; 
+        return harr[0]; 
+    } 
+  
+    // Store the minimum value, and remove it from heap 
+    int root = harr[0]; 
+    harr[0] = harr[heap_size-1]; 
+    heap_size--; 
+    MinHeapify(0); 
+  
+    return root; 
+} 
+  
+  
+// This function deletes key at index i. It first reduced value to minus 
+// infinite, then calls extractMin() 
+void MinHeap::deleteKey(int i) 
+{ 
+    decreaseKey(i, INT_MIN); 
+    extractMin(); 
+} 
+  
+// A recursive method to heapify a subtree with the root at given index 
+// This method assumes that the subtrees are already heapified 
+void MinHeap::MinHeapify(int i) 
+{ 
+    int l = left(i); 
+    int r = right(i); 
+    int smallest = i; 
+    if (l < heap_size && harr[l] < harr[i]) 
+        smallest = l; 
+    if (r < heap_size && harr[r] < harr[smallest]) 
+        smallest = r; 
+    if (smallest != i) 
+    { 
+        swap(&harr[i], &harr[smallest]); 
+        MinHeapify(smallest); 
+    } 
+} 
+  
+// A utility function to swap two elements 
+void swap(int *x, int *y) 
+{ 
+    int temp = *x; 
+    *x = *y; 
+    *y = temp; 
+} 
+  
+// Driver program to test above functions 
+int main() 
+{ 
+    MinHeap h(11); 
+    h.insertKey(3); 
+    h.insertKey(2); 
+    h.deleteKey(1); 
+    h.insertKey(15); 
+    h.insertKey(5); 
+    h.insertKey(4); 
+    h.insertKey(45); 
+    cout << h.extractMin() << " "; 
+    cout << h.getMin() << " "; 
+    h.decreaseKey(2, 1); 
+    cout << h.getMin(); 
+    return 0; 
+}