Skip to content
Related Articles

Related Articles

Print all nodes less than a value x in a Min Heap.

View Discussion
Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 19 Jul, 2022

Given a binary min heap and a value x, print all the binary heap nodes having value less than the given value x.

Examples : Consider the below min heap as
        common input two both below examples.
                   2
                /     \
               3        15
            /    \     / \
           5       4  45  80
          / \     / \
         6   150 77 120

Input  : x = 15        
Output : 2 3 5 6 4

Input  : x = 80
Output : 2 3 5 6 4 77 15 45

The idea is to do a preorder traversal of the give Binary heap. While doing preorder traversal, if the value of a node is greater than the given value x, we return to the previous recursive call. Because all children nodes in a min heap are greater than the parent node. Otherwise we print current node and recur for its children. 

Implementation:

C++




// A C++ program to print all values
// smaller than a given value in Binary
// Heap
#include <bits/stdc++.h>
using namespace std;
 
// A class for Min Heap
class MinHeap {
    // pointer to array of elements in heap
    int* harr;
 
    // maximum possible size of min heap
    int capacity;
    int heap_size; // Current no. of elements.
public:
    // Constructor
    MinHeap(int capacity);
 
    // to heapify a subtree with root at
    // given index
    void MinHeapify(int);
 
    int parent(int i) { return (i - 1) / 2; }
    int left(int i) { return (2 * i + 1); }
    int right(int i) { return (2 * i + 2); }
 
    // Inserts a new key 'k'
    void insertKey(int k);
 
    // Function to print all nodes smaller than k
    void printSmallerThan(int k, int pos);
};
 
// Function to print all elements smaller than k
void MinHeap::printSmallerThan(int x, int pos = 0)
{
    /* Make sure item exists */
    if (pos >= heap_size)
        return;
 
    if (harr[pos] >= x) {
        /* Skip this node and its descendants,
          as they are all >= x . */
        return;
    }
 
    cout << harr[pos] << " ";
 
    printSmallerThan(x, left(pos));
    printSmallerThan(x, right(pos));
}
 
// 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);
    }
}
 
// A recursive method to heapify a subtree with
// 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);
    }
}
 
// Driver program to test above functions
int main()
{
    MinHeap h(50);
    h.insertKey(3);
    h.insertKey(2);
    h.insertKey(15);
    h.insertKey(5);
    h.insertKey(4);
    h.insertKey(45);
    h.insertKey(80);
    h.insertKey(6);
    h.insertKey(150);
    h.insertKey(77);
    h.insertKey(120);
 
    // Print all nodes smaller than 100.
    int x = 100;
    h.printSmallerThan(x);
 
    return 0;
}

Java




// A Java program to print all values
// smaller than a given value in Binary
// Heap
 
// A class for Min Heap
class MinHeap {
    // array of elements in heap
    int[] harr;
 
    // maximum possible size of min heap
    int capacity;
    int heap_size; // Current no. of elements.
 
    int parent(int i) { return (i - 1) / 2; }
    int left(int i) { return (2 * i + 1); }
    int right(int i) { return (2 * i + 2); }
 
    // Function to print all elements smaller than k
    void printSmallerThan(int x, int pos)
    {
        /* Make sure item exists */
        if (pos >= heap_size)
            return;
 
        if (harr[pos] >= x) {
            /* Skip this node and its descendants,
            as they are all >= x . */
            return;
        }
 
        System.out.print(harr[pos] + " ");
 
        printSmallerThan(x, left(pos));
        printSmallerThan(x, right(pos));
    }
 
    // Constructor: Builds a heap of given size
    public MinHeap(int cap)
    {
        heap_size = 0;
        capacity = cap;
        harr = new int[cap];
    }
 
    // Inserts a new key 'k'
    void insertKey(int k)
    {
        if (heap_size == capacity) {
            System.out.println("Overflow: Could not insertKey");
            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(i, parent(i));
            i = parent(i);
        }
    }
 
    // A utility function to swap two elements
    void swap(int x, int y)
    {
        int temp = harr[x];
        harr[x] = harr[y];
        harr[y] = temp;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        MinHeap h = new MinHeap(15);
        h.insertKey(3);
        h.insertKey(2);
        h.insertKey(15);
        h.insertKey(5);
        h.insertKey(4);
        h.insertKey(45);
        h.insertKey(80);
        h.insertKey(6);
        h.insertKey(150);
        h.insertKey(77);
        h.insertKey(120);
 
        // Print all nodes smaller than 100.
        int x = 100;
        h.printSmallerThan(x, 0);
    }
};
 
// This code is contributed by shubham96301

C#




// A C# program to print all values
// smaller than a given value in
// Binary Heap
using System;
 
// A class for Min Heap
public class MinHeap
{
    // array of elements in heap
    int[] harr;
 
    // maximum possible size of min heap
    int capacity;
     
    // Current no. of elements
    int heap_size;
 
    int parent(int i) { return (i - 1) / 2; }
    int left(int i) { return (2 * i + 1); }
    int right(int i) { return (2 * i + 2); }
 
    // Function to print
    // all elements smaller than k
    void printSmallerThan(int x, int pos)
    {
        /* Make sure item exists */
        if (pos >= heap_size)
            return;
 
        if (harr[pos] >= x)
        {
            /* Skip this node and its descendants,
            as they are all >= x . */
            return;
        }
 
        Console.Write(harr[pos] + " ");
 
        printSmallerThan(x, left(pos));
        printSmallerThan(x, right(pos));
    }
 
    // Constructor: Builds a heap of given size
    public MinHeap(int cap)
    {
        heap_size = 0;
        capacity = cap;
        harr = new int[cap];
    }
 
    // Inserts a new key 'k'
    void insertKey(int k)
    {
        if (heap_size == capacity)
        {
            Console.WriteLine("Overflow: Could not insertKey");
            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(i, parent(i));
            i = parent(i);
        }
    }
 
    // A utility function to swap two elements
    void swap(int x, int y)
    {
        int temp = harr[x];
        harr[x] = harr[y];
        harr[y] = temp;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        MinHeap h = new MinHeap(15);
        h.insertKey(3);
        h.insertKey(2);
        h.insertKey(15);
        h.insertKey(5);
        h.insertKey(4);
        h.insertKey(45);
        h.insertKey(80);
        h.insertKey(6);
        h.insertKey(150);
        h.insertKey(77);
        h.insertKey(120);
 
        // Print all nodes smaller than 100.
        int x = 100;
        h.printSmallerThan(x, 0);
    }
}
 
// This code is contributed by PrinciRaj1992

Javascript




<script>
 
// A JavaScript program to print all values
// smaller than a given value in Binary
// Heap
 
// A class for Min Heap
class MinHeap {
 
    // Constructor: Builds a heap of given size
    constructor(capacity){
        this.harr = new Array(capacity); // array of elements in heap
        this.capacity = capacity; // maximum possible size of min heap
        this.heap_size = 0; // Current no. of elements.
    }
 
    parent(i) { return parseInt((i - 1) / 2); }
    left(i) { return (2 * i + 1); }
    right(i) { return (2 * i + 2); }
 
    // Function to print all elements smaller than k
    printSmallerThan(x, pos)
    {
        /* Make sure item exists */
        if (pos >= this.heap_size)
            return;
 
        if (this.harr[pos] >= x) {
            /* Skip this node and its descendants,
            as they are all >= x . */
            return;
        }
 
        document.write(this.harr[pos] , " ");
 
        this.printSmallerThan(x, this.left(pos));
        this.printSmallerThan(x, this.right(pos));
    }
 
    // A utility function to swap two elements
    swap(x, y)
    {
        let temp = this.harr[x];
        this.harr[x] = this.harr[y];
        this.harr[y] = temp;
    }
 
    // Inserts a new key 'k'
    insertKey(k)
    {
        if (this.heap_size == this.capacity) {
            System.out.println("Overflow: Could not insertKey");
            return;
        }
 
        // First insert the new key at the end
        this.heap_size++;
        let i = this.heap_size - 1;
        this.harr[i] = k;
 
        // Fix the min heap property if it is violated
        while (i != 0 && this.harr[this.parent(i)] > this.harr[i]) {
            this.swap(i, this.parent(i));
            i = this.parent(i);
        }
    }
 
}
 
// Driver code
 
let h = new MinHeap(15);
h.insertKey(3);
h.insertKey(2);
h.insertKey(15);
h.insertKey(5);
h.insertKey(4);
h.insertKey(45);
h.insertKey(80);
h.insertKey(6);
h.insertKey(150);
h.insertKey(77);
h.insertKey(120);
 
// Print all nodes smaller than 100.
let x = 100;
h.printSmallerThan(x, 0);
     
// This code is contributed by Shinjan Patra   
 
</script>

Output

2 3 5 6 4 77 15 45 80 

This article is contributed by Raghav Sharma. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!