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

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 given 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 ``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`

## Python3

 `# A Python program to print all values``# smaller than a given value in Binary``# Heap` `# A class for Min Heap``class` `MinHeap:``    ``# pointer to array of elements in heap``    ``harr ``=` `[]` `    ``# maximum possible size of min heap``    ``capacity ``=` `0``    ``heap_size ``=` `0`  `# Current no. of elements.` `    ``# Constructor``    ``def` `__init__(``self``, capacity):``        ``self``.heap_size ``=` `0``        ``self``.capacity ``=` `capacity``        ``self``.harr ``=` `[``0``] ``*` `capacity` `    ``# to heapify a subtree with root at``    ``# given index``    ``def` `MinHeapify(``self``, i):``        ``l ``=` `self``.left(i)``        ``r ``=` `self``.right(i)``        ``smallest ``=` `i``        ``if` `l < ``self``.heap_size ``and` `self``.harr[l] < ``self``.harr[i]:``            ``smallest ``=` `l``        ``if` `r < ``self``.heap_size ``and` `self``.harr[r] < ``self``.harr[smallest]:``            ``smallest ``=` `r``        ``if` `smallest !``=` `i:``            ``self``.harr[i], ``self``.harr[smallest] ``=` `self``.harr[smallest], ``self``.harr[i]``            ``self``.MinHeapify(smallest)` `    ``def` `parent(``self``, i):``        ``return` `(i ``-` `1``) ``/``/` `2` `    ``def` `left(``self``, i):``        ``return` `(``2` `*` `i ``+` `1``)` `    ``def` `right(``self``, i):``        ``return` `(``2` `*` `i ``+` `2``)` `    ``# Inserts a new key 'k'``    ``def` `insertKey(``self``, k):``        ``if` `self``.heap_size ``=``=` `self``.capacity:``            ``print``(``"\nOverflow: Could not insertKey\n"``)``            ``return``        ``# First insert the new key at the end``        ``self``.heap_size ``+``=` `1``        ``i ``=` `self``.heap_size ``-` `1``        ``self``.harr[i] ``=` `k``        ``# Fix the min heap property if it is violated``        ``while` `i !``=` `0` `and` `self``.harr[``self``.parent(i)] > ``self``.harr[i]:``            ``self``.harr[i], ``self``.harr[``self``.parent(i)] ``=` `self``.harr[``self``.parent(i)], ``self``.harr[i]``            ``i ``=` `self``.parent(i)` `    ``# Function to print all nodes smaller than k``    ``def` `printSmallerThan(``self``, x, pos``=``0``):``        ``"""``        ``Make sure item exists``        ``"""``        ``if` `pos >``=` `self``.heap_size:``            ``return``        ``if` `self``.harr[pos] >``=` `x:``            ``"""``            ``Skip this node and its descendants,``            ``as they are all >= x .``            ``"""``            ``return``        ``print``(``self``.harr[pos], end``=``" "``)``        ``self``.printSmallerThan(x, ``self``.left(pos))``        ``self``.printSmallerThan(x, ``self``.right(pos))`  `# Driver program to test above functions``def` `main():``    ``h ``=` `MinHeap(``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.``    ``x ``=` `100``    ``h.printSmallerThan(x)` `if` `__name__ ``=``=` `"__main__"``:``    ``main()` `    ``# This code is contributed by vikramshirsath177.`

## 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

 ``

Output
`2 3 5 6 4 77 15 45 80 `

Time Complexity: O(n)
Auxiliary Space: O(1)

Previous
Next