Print all the leaf nodes of binary heap
Here given code implementation process.
// C Program
// Print all the leaf nodes of binary heap
#include <stdio.h>
//Swap two element in array
void swap(int arr[], int first, int second)
{
int auxiliary = arr[first];
arr[first] = arr[second];
arr[second] = auxiliary;
}
// This is converting given root and its leaf into a valid min heap form
void minHeap(int arr[], int size, int root)
{
int left = 2 *root + 1;
int right = 2 *root + 2;
int task = -1;
if (left < size && arr[left] < arr[root])
{
if (right < size && arr[right] < arr[left])
{
// When right child is less than left child
swap(arr, right, root);
task = right;
}
else
{
// When left child is less than root node
swap(arr, left, root);
task = left;
}
}
else if (right < size && arr[right] < arr[root])
{
// When right child is less than root node
swap(arr, right, root);
task = right;
}
if (task != -1)
{
// Execute function until when changes are required
minHeap(arr, size, task);
}
}
// Show array elements
void printData(int arr[], int size)
{
printf("\n");
for (int i = 0; i < size; i++)
{
printf("%3d", arr[i]);
}
}
// Display leaf nodes
void leafNodes(int node[], int size, int root)
{
if (root < size)
{
if ((2 *root + 1) >= size && (2 *root + 2) >= size)
{
printf("%3d", node[root]);
}
// Recursive visit to child node
leafNodes(node, size, 2 *root + 1);
leafNodes(node, size, 2 *root + 2);
}
}
// Handles the request of construct min heap in given array
void buildMinHeap(int arr[], int size)
{
for (int i = (size / 2); i >= 0; i--)
{
minHeap(arr, size, i);
}
}
int main()
{
// Array elements
int arr[] = {
4 , 7 , 8 , 2 , 9 , 3 , 1 , 6 , 10
};
// Find number of element in array
int size = sizeof(arr) / sizeof(arr[0]);
buildMinHeap(arr, size);
/*
Construct Min heap
1
/ \
/ \
2 3
/ \ / \
6 9 4 8
/ \
7 10
*/
printf("\n Construct Min Heap ");
//Display heap elements
printData(arr, size);
printf("\n Leaf nodes \n");
leafNodes(arr, size, 0);
return 0;
}
Output
Construct Min Heap
1 2 3 6 9 4 8 7 10
Leaf nodes
7 10 9 4 8
/*
Java program
Print all the leaf nodes of binary heap
*/
public class MinHeap
{
//Swap two element in array
public void swap(int[] arr, int first, int second)
{
int auxiliary = arr[first];
arr[first] = arr[second];
arr[second] = auxiliary;
}
// This is converting given root and its leaf into a valid min heap form
public void minHeap(int[] arr, int size, int root)
{
int left = 2 * root + 1;
int right = 2 * root + 2;
int task = -1;
if (left < size && arr[left] < arr[root])
{
if (right < size && arr[right] < arr[left])
{
// When right child is less than left child
swap(arr, right, root);
task = right;
}
else
{
// When left child is less than root node
swap(arr, left, root);
task = left;
}
}
else if (right < size && arr[right] < arr[root])
{
// When right child is less than root node
swap(arr, right, root);
task = right;
}
if (task != -1)
{
// Execute function until when changes are required
minHeap(arr, size, task);
}
}
// Show array elements
public void printData(int[] arr, int size)
{
System.out.print("\n");
for (int i = 0; i < size; i++)
{
System.out.print(" " + arr[i]);
}
}
// Display leaf nodes
public void leafNodes(int[] node, int size, int root)
{
if (root < size)
{
if ((2 * root + 1) >= size && (2 * root + 2) >= size)
{
System.out.print(" " + node[root]);
}
// Recursive visit to child node
leafNodes(node, size, 2 * root + 1);
leafNodes(node, size, 2 * root + 2);
}
}
// Handles the request of construct min heap in given array
public void buildMinHeap(int[] arr, int size)
{
for (int i = (size / 2); i >= 0; i--)
{
minHeap(arr, size, i);
}
}
public static void main(String[] args)
{
MinHeap task = new MinHeap();
// Array elements
int[] arr = {
4 , 7 , 8 , 2 , 9 , 3 , 1 , 6 , 10
};
// Find number of element in array
int size = arr.length;
task.buildMinHeap(arr, size);
/*
Construct Min heap
1
/ \
/ \
2 3
/ \ / \
6 9 4 8
/ \
7 10
*/
System.out.print("\n Construct Min Heap ");
//Display heap elements
task.printData(arr, size);
System.out.print("\n Leaf nodes \n");
task.leafNodes(arr, size, 0);
}
}
Output
Construct Min Heap
1 2 3 6 9 4 8 7 10
Leaf nodes
7 10 9 4 8
// Include header file
#include <iostream>
using namespace std;
/*
C++ program
Print all the leaf nodes of binary heap
*/
class MinHeap
{
public:
//Swap two element in array
void swap(int arr[], int first, int second)
{
int auxiliary = arr[first];
arr[first] = arr[second];
arr[second] = auxiliary;
}
// This is converting given root and its leaf into a valid min heap form
void minHeap(int arr[], int size, int root)
{
int left = 2 *root + 1;
int right = 2 *root + 2;
int task = -1;
if (left < size && arr[left] < arr[root])
{
if (right < size && arr[right] < arr[left])
{
// When right child is less than left child
this->swap(arr, right, root);
task = right;
}
else
{
// When left child is less than root node
this->swap(arr, left, root);
task = left;
}
}
else if (right < size && arr[right] < arr[root])
{
// When right child is less than root node
this->swap(arr, right, root);
task = right;
}
if (task != -1)
{
// Execute function until when changes are required
this->minHeap(arr, size, task);
}
}
// Show array elements
void printData(int arr[], int size)
{
cout << "\n";
for (int i = 0; i < size; i++)
{
cout << " " << arr[i];
}
}
// Display leaf nodes
void leafNodes(int node[], int size, int root)
{
if (root < size)
{
if ((2 *root + 1) >= size && (2 *root + 2) >= size)
{
cout << " " << node[root];
}
// Recursive visit to child node
this->leafNodes(node, size, 2 *root + 1);
this->leafNodes(node, size, 2 *root + 2);
}
}
// Handles the request of construct min heap in given array
void buildMinHeap(int arr[], int size)
{
for (int i = (size / 2); i >= 0; i--)
{
this->minHeap(arr, size, i);
}
}
};
int main()
{
MinHeap task = MinHeap();
// Array elements
int arr[] = {
4 , 7 , 8 , 2 , 9 , 3 , 1 , 6 , 10
};
// Find number of element in array
int size = sizeof(arr) / sizeof(arr[0]);
task.buildMinHeap(arr, size);
/*
Construct Min heap
1
/ \
/ \
2 3
/ \ / \
6 9 4 8
/ \
7 10
*/
cout << "\n Construct Min Heap ";
//Display heap elements
task.printData(arr, size);
cout << "\n Leaf nodes \n";
task.leafNodes(arr, size, 0);
return 0;
}
Output
Construct Min Heap
1 2 3 6 9 4 8 7 10
Leaf nodes
7 10 9 4 8
// Include namespace system
using System;
/*
C# program
Print all the leaf nodes of binary heap
*/
public class MinHeap
{
//Swap two element in array
public void swap(int[] arr, int first, int second)
{
int auxiliary = arr[first];
arr[first] = arr[second];
arr[second] = auxiliary;
}
// This is converting given root and its leaf into a valid min heap form
public void minHeap(int[] arr, int size, int root)
{
int left = 2 * root + 1;
int right = 2 * root + 2;
int task = -1;
if (left < size && arr[left] < arr[root])
{
if (right < size && arr[right] < arr[left])
{
// When right child is less than left child
swap(arr, right, root);
task = right;
}
else
{
// When left child is less than root node
swap(arr, left, root);
task = left;
}
}
else if (right < size && arr[right] < arr[root])
{
// When right child is less than root node
swap(arr, right, root);
task = right;
}
if (task != -1)
{
// Execute function until when changes are required
minHeap(arr, size, task);
}
}
// Show array elements
public void printData(int[] arr, int size)
{
Console.Write("\n");
for (int i = 0; i < size; i++)
{
Console.Write(" " + arr[i]);
}
}
// Display leaf nodes
public void leafNodes(int[] node, int size, int root)
{
if (root < size)
{
if ((2 * root + 1) >= size && (2 * root + 2) >= size)
{
Console.Write(" " + node[root]);
}
// Recursive visit to child node
leafNodes(node, size, 2 * root + 1);
leafNodes(node, size, 2 * root + 2);
}
}
// Handles the request of construct min heap in given array
public void buildMinHeap(int[] arr, int size)
{
for (int i = (size / 2); i >= 0; i--)
{
minHeap(arr, size, i);
}
}
public static void Main(String[] args)
{
MinHeap task = new MinHeap();
// Array elements
int[] arr = {
4 , 7 , 8 , 2 , 9 , 3 , 1 , 6 , 10
};
// Find number of element in array
int size = arr.Length;
task.buildMinHeap(arr, size);
/*
Construct Min heap
1
/ \
/ \
2 3
/ \ / \
6 9 4 8
/ \
7 10
*/
Console.Write("\n Construct Min Heap ");
//Display heap elements
task.printData(arr, size);
Console.Write("\n Leaf nodes \n");
task.leafNodes(arr, size, 0);
}
}
Output
Construct Min Heap
1 2 3 6 9 4 8 7 10
Leaf nodes
7 10 9 4 8
<?php
/*
Php program
Print all the leaf nodes of binary heap
*/
class MinHeapTree
{
//Swap two element in array
public function swap( & $arr, $first, $second)
{
$auxiliary = $arr[$first];
$arr[$first] = $arr[$second];
$arr[$second] = $auxiliary;
}
// This is converting given root and its leaf into a valid min heap form
public function minHeap( & $arr, $size, $root)
{
$left = 2 * $root + 1;
$right = 2 * $root + 2;
$task = -1;
if ($left < $size && $arr[$left] < $arr[$root])
{
if ($right < $size && $arr[$right] < $arr[$left])
{
// When right child is less than left child
$this->swap($arr, $right, $root);
$task = $right;
}
else
{
// When left child is less than root node
$this->swap($arr, $left, $root);
$task = $left;
}
}
else if ($right < $size && $arr[$right] < $arr[$root])
{
// When right child is less than root node
$this->swap($arr, $right, $root);
$task = $right;
}
if ($task != -1)
{
// Execute function until when changes are required
$this->minHeap($arr, $size, $task);
}
}
// Show array elements
public function printData( & $arr, $size)
{
echo "\n";
for ($i = 0; $i < $size; $i++)
{
echo " ". $arr[$i];
}
}
// Display leaf nodes
public function leafNodes( & $node, $size, $root)
{
if ($root < $size)
{
if ((2 * $root + 1) >= $size && (2 * $root + 2) >= $size)
{
echo " ". $node[$root];
}
// Recursive visit to child node
$this->leafNodes($node, $size, 2 * $root + 1);
$this->leafNodes($node, $size, 2 * $root + 2);
}
}
// Handles the request of construct min heap in given array
public function buildMinHeap( & $arr, $size)
{
for ($i = (intval($size / 2)); $i >= 0; $i--)
{
$this->minHeap($arr, $size, $i);
}
}
}
function main()
{
$task = new MinHeapTree();
// Array elements
$arr = array(4, 7, 8, 2, 9, 3, 1, 6, 10);
// Find number of element in array
$size = count($arr);
$task->buildMinHeap($arr, $size);
/*
Construct Min heap
1
/ \
/ \
2 3
/ \ / \
6 9 4 8
/ \
7 10
*/
echo "\n Construct Min Heap ";
//Display heap elements
$task->printData($arr, $size);
echo "\n Leaf nodes \n";
$task->leafNodes($arr, $size, 0);
}
main();
Output
Construct Min Heap
1 2 3 6 9 4 8 7 10
Leaf nodes
7 10 9 4 8
/*
Node Js program
Print all the leaf nodes of binary heap
*/
class MinHeapTree
{
//Swap two element in array
swap(arr, first, second)
{
var auxiliary = arr[first];
arr[first] = arr[second];
arr[second] = auxiliary;
}
// This is converting given root and its leaf into a valid min heap form
minHeap(arr, size, root)
{
var left = 2 * root + 1;
var right = 2 * root + 2;
var task = -1;
if (left < size && arr[left] < arr[root])
{
if (right < size && arr[right] < arr[left])
{
// When right child is less than left child
this.swap(arr, right, root);
task = right;
}
else
{
// When left child is less than root node
this.swap(arr, left, root);
task = left;
}
}
else if (right < size && arr[right] < arr[root])
{
// When right child is less than root node
this.swap(arr, right, root);
task = right;
}
if (task != -1)
{
// Execute function until when changes are required
this.minHeap(arr, size, task);
}
}
// Show array elements
printData(arr, size)
{
process.stdout.write("\n");
for (var i = 0; i < size; i++)
{
process.stdout.write(" " + arr[i]);
}
}
// Display leaf nodes
leafNodes(node, size, root)
{
if (root < size)
{
if ((2 * root + 1) >= size && (2 * root + 2) >= size)
{
process.stdout.write(" " + node[root]);
}
// Recursive visit to child node
this.leafNodes(node, size, 2 * root + 1);
this.leafNodes(node, size, 2 * root + 2);
}
}
// Handles the request of construct min heap in given array
buildMinHeap(arr, size)
{
for (var i = (parseInt(size / 2)); i >= 0; i--)
{
this.minHeap(arr, size, i);
}
}
}
function main()
{
var task = new MinHeapTree();
// Array elements
var arr = [4, 7, 8, 2, 9, 3, 1, 6, 10];
// Find number of element in array
var size = arr.length;
task.buildMinHeap(arr, size);
/*
Construct Min heap
1
/ \
/ \
2 3
/ \ / \
6 9 4 8
/ \
7 10
*/
process.stdout.write("\n Construct Min Heap ");
//Display heap elements
task.printData(arr, size);
process.stdout.write("\n Leaf nodes \n");
task.leafNodes(arr, size, 0);
}
main();
Output
Construct Min Heap
1 2 3 6 9 4 8 7 10
Leaf nodes
7 10 9 4 8
# Python 3 program
# Print all the leaf nodes of binary heap
class MinHeapTree :
# Swap two element in array
def swap(self, arr, first, second) :
auxiliary = arr[first]
arr[first] = arr[second]
arr[second] = auxiliary
# This is converting given root and its leaf into a valid min heap form
def minHeap(self, arr, size, root) :
left = 2 * root + 1
right = 2 * root + 2
task = -1
if (left < size and arr[left] < arr[root]) :
if (right < size and arr[right] < arr[left]) :
# When right child is less than left child
self.swap(arr, right, root)
task = right
else :
# When left child is less than root node
self.swap(arr, left, root)
task = left
elif(right < size and arr[right] < arr[root]) :
# When right child is less than root node
self.swap(arr, right, root)
task = right
if (task != -1) :
# Execute function until when changes are required
self.minHeap(arr, size, task)
# Show array elements
def printData(self, arr, size) :
print(end = "\n")
i = 0
while (i < size) :
print(" ", arr[i], end = "")
i += 1
# Display leaf nodes
def leafNodes(self, node, size, root) :
if (root < size) :
if ((2 * root + 1) >= size and(2 * root + 2) >= size) :
print(" ", node[root], end = "")
# Recursive visit to child node
self.leafNodes(node, size, 2 * root + 1)
self.leafNodes(node, size, 2 * root + 2)
# Handles the request of construct min heap in given array
def buildMinHeap(self, arr, size) :
i = (int(size / 2))
while (i >= 0) :
self.minHeap(arr, size, i)
i -= 1
def main() :
task = MinHeapTree()
# Array elements
arr = [4, 7, 8, 2, 9, 3, 1, 6, 10]
# Find number of element in array
size = len(arr)
task.buildMinHeap(arr, size)
#
# Construct Min heap
# 1
# / \
# / \
# 2 3
# / \ / \
# 6 9 4 8
# / \
# 7 10
print("\n Construct Min Heap ", end = "")
# Display heap elements
task.printData(arr, size)
print("\n Leaf nodes ")
task.leafNodes(arr, size, 0)
if __name__ == "__main__": main()
Output
Construct Min Heap
1 2 3 6 9 4 8 7 10
Leaf nodes
7 10 9 4 8
# Ruby program
# Print all the leaf nodes of binary heap
class MinHeapTree
# Swap two element in array
def swap(arr, first, second)
auxiliary = arr[first]
arr[first] = arr[second]
arr[second] = auxiliary
end
# This is converting given root and its leaf into a valid min heap form
def minHeap(arr, size, root)
left = 2 * root + 1
right = 2 * root + 2
task = -1
if (left < size && arr[left] < arr[root])
if (right < size && arr[right] < arr[left])
# When right child is less than left child
self.swap(arr, right, root)
task = right
else
# When left child is less than root node
self.swap(arr, left, root)
task = left
end
elsif(right < size && arr[right] < arr[root])
# When right child is less than root node
self.swap(arr, right, root)
task = right
end
if (task != -1)
# Execute function until when changes are required
self.minHeap(arr, size, task)
end
end
# Show array elements
def printData(arr, size)
print("\n")
i = 0
while (i < size)
print(" ", arr[i])
i += 1
end
end
# Display leaf nodes
def leafNodes(node, size, root)
if (root < size)
if ((2 * root + 1) >= size && (2 * root + 2) >= size)
print(" ", node[root])
end
# Recursive visit to child node
self.leafNodes(node, size, 2 * root + 1)
self.leafNodes(node, size, 2 * root + 2)
end
end
# Handles the request of construct min heap in given array
def buildMinHeap(arr, size)
i = (size / 2)
while (i >= 0)
self.minHeap(arr, size, i)
i -= 1
end
end
end
def main()
task = MinHeapTree.new()
# Array elements
arr = [4, 7, 8, 2, 9, 3, 1, 6, 10]
# Find number of element in array
size = arr.length
task.buildMinHeap(arr, size)
#
# Construct Min heap
# 1
# / \
# / \
# 2 3
# / \ / \
# 6 9 4 8
# / \
# 7 10
print("\n Construct Min Heap ")
# Display heap elements
task.printData(arr, size)
print("\n Leaf nodes \n")
task.leafNodes(arr, size, 0)
end
main()
Output
Construct Min Heap
1 2 3 6 9 4 8 7 10
Leaf nodes
7 10 9 4 8
/*
Scala program
Print all the leaf nodes of binary heap
*/
class MinHeapTree
{
//Swap two element in array
def swap(arr: Array[Int], first: Int, second: Int): Unit = {
var auxiliary: Int = arr(first);
arr(first) = arr(second);
arr(second) = auxiliary;
}
// This is converting given root and its leaf into a valid min heap form
def minHeap(arr: Array[Int], size: Int, root: Int): Unit = {
var left: Int = 2 * root + 1;
var right: Int = 2 * root + 2;
var task: Int = -1;
if (left < size && arr(left) < arr(root))
{
if (right < size && arr(right) < arr(left))
{
// When right child is less than left child
this.swap(arr, right, root);
task = right;
}
else
{
// When left child is less than root node
this.swap(arr, left, root);
task = left;
}
}
else if (right < size && arr(right) < arr(root))
{
// When right child is less than root node
this.swap(arr, right, root);
task = right;
}
if (task != -1)
{
// Execute function until when changes are required
this.minHeap(arr, size, task);
}
}
// Show array elements
def printData(arr: Array[Int], size: Int): Unit = {
print("\n");
var i: Int = 0;
while (i < size)
{
print(" " + arr(i));
i += 1;
}
}
// Display leaf nodes
def leafNodes(node: Array[Int], size: Int, root: Int): Unit = {
if (root < size)
{
if ((2 * root + 1) >= size && (2 * root + 2) >= size)
{
print(" " + node(root));
}
// Recursive visit to child node
this.leafNodes(node, size, 2 * root + 1);
this.leafNodes(node, size, 2 * root + 2);
}
}
// Handles the request of construct min heap in given array
def buildMinHeap(arr: Array[Int], size: Int): Unit = {
var i: Int = ((size / 2).toInt);
while (i >= 0)
{
this.minHeap(arr, size, i);
i -= 1;
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: MinHeapTree = new MinHeapTree();
// Array elements
var arr: Array[Int] = Array(4, 7, 8, 2, 9, 3, 1, 6, 10);
// Find number of element in array
var size: Int = arr.length;
task.buildMinHeap(arr, size);
/*
Construct Min heap
1
/ \
/ \
2 3
/ \ / \
6 9 4 8
/ \
7 10
*/
print("\n Construct Min Heap ");
//Display heap elements
task.printData(arr, size);
print("\n Leaf nodes \n");
task.leafNodes(arr, size, 0);
}
}
Output
Construct Min Heap
1 2 3 6 9 4 8 7 10
Leaf nodes
7 10 9 4 8
/*
Swift 4 program
Print all the leaf nodes of binary heap
*/
class MinHeapTree
{
//Swap two element in array
func swap(_ arr: inout[Int], _ first: Int, _ second: Int)
{
let auxiliary: Int = arr[first];
arr[first] = arr[second];
arr[second] = auxiliary;
}
// This is converting given root and its leaf into a valid min heap form
func minHeap(_ arr: inout[Int], _ size: Int, _ root: Int)
{
let left: Int = 2 * root + 1;
let right: Int = 2 * root + 2;
var task: Int = -1;
if (left < size && arr[left] < arr[root])
{
if (right < size && arr[right] < arr[left])
{
// When right child is less than left child
self.swap(&arr, right, root);
task = right;
}
else
{
// When left child is less than root node
self.swap(&arr, left, root);
task = left;
}
}
else if (right < size && arr[right] < arr[root])
{
// When right child is less than root node
self.swap(&arr, right, root);
task = right;
}
if (task != -1)
{
// Execute function until when changes are required
self.minHeap(&arr, size, task);
}
}
// Show array elements
func printData(_ arr: [Int], _ size: Int)
{
print(terminator: "\n");
var i: Int = 0;
while (i < size)
{
print(" ", arr[i], terminator: "");
i += 1;
}
}
// Display leaf nodes
func leafNodes(_ node: [Int], _ size: Int, _ root: Int)
{
if (root < size)
{
if ((2 * root + 1) >= size && (2 * root + 2) >= size)
{
print(" ", node[root], terminator: "");
}
// Recursive visit to child node
self.leafNodes(node, size, 2 * root + 1);
self.leafNodes(node, size, 2 * root + 2);
}
}
// Handles the request of construct min heap in given array
func buildMinHeap(_ arr: inout[Int], _ size: Int)
{
var i: Int = (size / 2);
while (i >= 0)
{
self.minHeap(&arr, size, i);
i -= 1;
}
}
}
func main()
{
let task: MinHeapTree = MinHeapTree();
// Array elements
var arr: [Int] = [4, 7, 8, 2, 9, 3, 1, 6, 10];
// Find number of element in array
let size: Int = arr.count;
task.buildMinHeap(&arr, size);
/*
Construct Min heap
1
/ \
/ \
2 3
/ \ / \
6 9 4 8
/ \
7 10
*/
print("\n Construct Min Heap ", terminator: "");
//Display heap elements
task.printData(arr, size);
print("\n Leaf nodes ");
task.leafNodes(arr, size, 0);
}
main();
Output
Construct Min Heap
1 2 3 6 9 4 8 7 10
Leaf nodes
7 10 9 4 8
/*
Kotlin program
Print all the leaf nodes of binary heap
*/
class MinHeapTree
{
//Swap two element in array
fun swap(arr: Array <Int> , first: Int, second: Int): Unit
{
var auxiliary: Int = arr[first];
arr[first] = arr[second];
arr[second] = auxiliary;
}
// This is converting given root and its leaf into a valid min heap form
fun minHeap(arr: Array <Int> , size: Int, root: Int): Unit
{
var left: Int = 2 * root + 1;
var right: Int = 2 * root + 2;
var task: Int = -1;
if (left < size && arr[left] < arr[root])
{
if (right < size && arr[right] < arr[left])
{
// When right child is less than left child
this.swap(arr, right, root);
task = right;
}
else
{
// When left child is less than root node
this.swap(arr, left, root);
task = left;
}
}
else if (right < size && arr[right] < arr[root])
{
// When right child is less than root node
this.swap(arr, right, root);
task = right;
}
if (task != -1)
{
// Execute function until when changes are required
this.minHeap(arr, size, task);
}
}
// Show array elements
fun printData(arr: Array < Int > , size: Int): Unit
{
print("\n");
var i: Int = 0;
while (i < size)
{
print(" " + arr[i]);
i += 1;
}
}
// Display leaf nodes
fun leafNodes(node: Array < Int > , size: Int, root: Int): Unit
{
if (root < size)
{
if ((2 * root + 1) >= size && (2 * root + 2) >= size)
{
print(" " + node[root]);
}
// Recursive visit to child node
this.leafNodes(node, size, 2 * root + 1);
this.leafNodes(node, size, 2 * root + 2);
}
}
// Handles the request of construct min heap in given array
fun buildMinHeap(arr: Array < Int > , size: Int): Unit
{
var i: Int = (size / 2);
while (i >= 0)
{
this.minHeap(arr, size, i);
i -= 1;
}
}
}
fun main(args: Array <String> ): Unit
{
var task: MinHeapTree = MinHeapTree();
// Array elements
var arr: Array <Int> = arrayOf(4, 7, 8, 2, 9, 3, 1, 6, 10);
// Find number of element in array
var size: Int = arr.count();
task.buildMinHeap(arr, size);
/*
Construct Min heap
1
/ \
/ \
2 3
/ \ / \
6 9 4 8
/ \
7 10
*/
print("\n Construct Min Heap ");
//Display heap elements
task.printData(arr, size);
print("\n Leaf nodes \n");
task.leafNodes(arr, size, 0);
}
Output
Construct Min Heap
1 2 3 6 9 4 8 7 10
Leaf nodes
7 10 9 4 8
Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.
New Comment