Open In App

Heap implementation in Java

Last Updated : 27 May, 2024
Comments
Improve
Suggest changes
Like Article
Like
Report

A heap is a binary tree-based data structure that adheres to a heap property. In a heap, every parent node has a specific relationship with its children: in a max-heap, each parent is greater than or equal to its children, while in a min-heap, each parent is less than or equal to its children. Heaps are commonly used to implement priority queues and are foundational for algorithms like heap-sort and Dijkstra's algorithm.

Organization of Heaps

Heaps are often implemented using arrays, leveraging the binary tree structure. The heap is typically visualized as a binary tree where

  • The root is at index 0
  • For any node at index i its left child is at index 2*i + 1 its right child is at index 2*i + 2 and its parent is at index (i - 1) / 2

Heap Diagram:

Here is a min-heap structure represented as both a tree and an array

Min-Heap as Tree:

Heap_in_Java


Min-Heap as Array:

[5, 10, 15, 20, 25, 30, 35]

Heap Implementation in Java:

To implement a heap in Java, you need to consider the operations required to maintain the heap property. Key operations include.

  • insert: Adds a new element and restores the heap property.
  • extract: Removes and returns the root element, then restores the heap property.
  • heapify: Re-balances the heap after an operation.

Basic Operations:

Operation

Algorithm

Complexity

Insert

  • Insert the new element at the end of the heap (the next available index in the array).
  • Bubble up the element to its correct position by comparing it with its parent until the heap property is restored.
  • Time complexity: O(log n)

Extract

  • Swap the root with the last element, then remove the last element (the original root).
  • Restore the heap property by "bubbling down" the new root until it finds the correct position.
  • Time complexity: O(log n)

Heapify

  • Given an array, this operation ensures it follows the heap property.
  • Start from the last non-leaf node and bubble down to maintain the heap structure.
  • Time complexity: O(n). This is because half of the nodes are leaves and require little or no adjustment.

Java Code To Implementation Min Heap

A Min Heap is a type of binary heap where the parent node is always less than or equal to its child nodes. This property must hold for every node in the heap. The smallest element is always at the root of the heap. A min heap is a complete binary tree, meaning all levels of the tree are fully filled except possibly the last level, which is filled from left to right.

Example:

Java 
// Java Program to Implement Min Heap
import java.util.ArrayList;

class MinHeap {
    private ArrayList<Integer> heap;

    // Constructor to initialize the heap
    public MinHeap() {
        heap = new ArrayList<>();
    }

    // Returns the index of the parent node
    private int parent(int i) {
        return (i - 1) / 2;
    }

    // Returns the index of the left child node
    private int leftChild(int i) {
        return 2 * i + 1;
    }

    // Returns the index of the right child node
    private int rightChild(int i) {
        return 2 * i + 2;
    }

    // Swaps the elements at indices i and j
    private void swap(int i, int j) {
        int temp = heap.get(i);
        heap.set(i, heap.get(j));
        heap.set(j, temp);
    }

    // Inserts a new value into the heap
    public void insert(int value) {
        // Add the new value at the end of the heap
        heap.add(value); 
        // Get the index of the newly added value
        int currentIndex = heap.size() - 1; 

        // Bubble up to restore heap property
        while (currentIndex > 0 && heap.get(currentIndex) < heap.get(parent(currentIndex))) {
            // Swap with parent if current value is less
            swap(currentIndex, parent(currentIndex)); 
            // Move up to the parent index
            currentIndex = parent(currentIndex); 
        }
    }

    // Extracts and returns the minimum value from the heap
    public int extractMin() {
        if (heap.isEmpty()) {
            throw new RuntimeException("Heap is empty");
        }

        // The minimum value is at the root
        int min = heap.get(0); 
        // Remove the last element
        int lastElement = heap.remove(heap.size() - 1); 

        if (!heap.isEmpty()) {
            // Move the last element to the root
            heap.set(0, lastElement); 

            // Bubble down to restore heap property
            int currentIndex = 0;
            while (true) {
                int left = leftChild(currentIndex);
                int right = rightChild(currentIndex);

                int smallest = currentIndex;

                // Find the smallest value among current, left child, and right child
                if (left < heap.size() && heap.get(left) < heap.get(smallest)) {
                    smallest = left;
                }

                if (right < heap.size() && heap.get(right) < heap.get(smallest)) {
                    smallest = right;
                }

                if (smallest == currentIndex) {
                    // Heap property is restored
                    break; 
                }

                // Swap with the smallest child
                swap(currentIndex, smallest); 
                // Move down to the smallest child's index
                currentIndex = smallest; 
            }
        }

        // Return the minimum value
        return min; 
    }

    // Checks if the heap is empty
    public boolean isEmpty() {
        return heap.isEmpty();
    }
}

public class HeapExample {
    public static void main(String[] args) {
        MinHeap minHeap = new MinHeap();

        // Insert values into the min heap
        minHeap.insert(10);
        minHeap.insert(5);
        minHeap.insert(15);
        minHeap.insert(20);
        minHeap.insert(25);

        // Extract and print the minimum values from the heap
        System.out.println("Extracted Min: " + minHeap.extractMin());
        System.out.println("Extracted Min: " + minHeap.extractMin());
    }
}

Output
Extracted Min: 5
Extracted Min: 10

Java Code To Implementation Max Heap

A Max Heap is a type of binary heap where the parent node is always greater than or equal to its child nodes. This property must hold for every node in the heap. The largest element is always at the root of the heap. A max heap is a complete binary tree, meaning all levels of the tree are fully filled except possibly the last level, which is filled from left to right.

Below is the Program Implementing the Max Heap:

Java 
// Java Program to Implement Max Heap
import java.util.ArrayList;

class MaxHeap {
    private ArrayList<Integer> heap;

    // Constructor to initialize the heap
    public MaxHeap() {
        heap = new ArrayList<>();
    }

    // Returns the index of the parent node
    private int parent(int i) {
        return (i - 1) / 2;
    }

    // Returns the index of the left child node
    private int leftChild(int i) {
        return 2 * i + 1;
    }

    // Returns the index of the right child node
    private int rightChild(int i) {
        return 2 * i + 2;
    }

    // Swaps the elements at indices i and j
    private void swap(int i, int j) {
        int temp = heap.get(i);
        heap.set(i, heap.get(j));
        heap.set(j, temp);
    }

    // Inserts a new value into the heap
    public void insert(int value) {
          // Add the new value at the end of the heap
        heap.add(value); 
      
          // Get the index of the newly added value
        int currentIndex = heap.size() - 1; 

        // Bubble up to restore heap property
        while (currentIndex > 0 && heap.get(currentIndex) > heap.get(parent(currentIndex))) {
              // Swap with parent if current value is greater
            swap(currentIndex, parent(currentIndex));
          
              // Move up to the parent index
            currentIndex = parent(currentIndex); 
        }
    }

    // Extracts and returns the maximum value from the heap
    public int extractMax() {
        if (heap.isEmpty()) {
            throw new RuntimeException("Heap is empty");
        }

          // The maximum value is at the root
        int max = heap.get(0); 
      
          // Remove the last element
        int lastElement = heap.remove(heap.size() - 1); 

        if (!heap.isEmpty()) {
          
              // Move the last element to the root
            heap.set(0, lastElement); 

            // Bubble down to restore heap property
            int currentIndex = 0;
            while (true) {
                int left = leftChild(currentIndex);
                int right = rightChild(currentIndex);

                int largest = currentIndex;

                // Find the largest value among current, left child, and right child
                if (left < heap.size() && heap.get(left) > heap.get(largest)) {
                    largest = left;
                }

                if (right < heap.size() && heap.get(right) > heap.get(largest)) {
                    largest = right;
                }

                if (largest == currentIndex) {
                      // Heap property is restored
                    break; 
                }

                  // Swap with the largest child
                swap(currentIndex, largest); 
              
                  // Move down to the largest child's index
                currentIndex = largest; 
            }
        }

          // Return the maximum value
        return max; 
    }

    // Checks if the heap is empty
    public boolean isEmpty() {
        return heap.isEmpty();
    }
}

public class HeapExample {
    public static void main(String[] args) {
        MaxHeap maxHeap = new MaxHeap();

        // Insert values into the max heap
        maxHeap.insert(10);
        maxHeap.insert(5);
        maxHeap.insert(15);
        maxHeap.insert(20);
        maxHeap.insert(25);

        // Extract and print the maximum values from the heap
        System.out.println("Extracted Max: " + maxHeap.extractMax());
        System.out.println("Extracted Max: " + maxHeap.extractMax());
    }
}

Output
Extracted Max: 25
Extracted Max: 20

Applications of Heaps

  • Priority Queues: Heaps are the underlying data structure for efficient priority queue operations.
  • Heap Sort: A sorting algorithm that leverages the heap property.
  • Graph Algorithms: Dijkstra's algorithm and Prim's algorithm use heaps for efficient vertex extraction.
  • Median Maintenance: In scenarios where the median needs to be maintained dynamically.

Conclusion

Heaps are versatile data structures with wide-ranging applications. Their efficient insertion and extraction operations make them ideal for implementing priority queues and optimizing graph algorithms. With a clear understanding of how heaps are structured and implemented in Java, you can leverage them in various problem-solving scenarios.


Next Article
Introduction to Java

E
eswararaobetha1
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox