Check whether binary tree is form of min heap
Here given code implementation process.
/*
C Program
Check whether binary tree is form of min heap
*/
#include <stdio.h>
#include <stdlib.h>
//structure of Binary Tree node
struct Node
{
int data;
struct Node*left,*right;
};
//Create a binary tree nodes and node fields (data,pointer)
//And returning the reference of newly nodes
struct Node* insert(int data)
{
//Create dynamic memory to new binary tree node
struct Node*new_node=(struct Node*)malloc(sizeof(struct Node));
if(new_node!=NULL){
//set data and pointer values
new_node->data=data;
new_node->left=NULL; //Initially node left-pointer is NULL
new_node->right=NULL;//Initially node right-pointer is NULL
}else
{
printf("Memory Overflow\n");
exit(0); //Terminate program execution
}
//return reference
return new_node;
}
//Check that given binary tree is form of min heap or not
int is_min_heap(struct Node*root)
{
if(root!=NULL)
{
if(root->left!=NULL && root->left->data < root->data ||
root->right!=NULL && root->right->data < root->data)
{
//When tree is not a min heap
return 0;
}
if(is_min_heap(root->left) && is_min_heap(root->right))
{
//When tree is min heap
return 1;
}
return 0;
}
return 1;
}
//Display tree element inorder form
void inorder(struct Node*node){
if(node){
inorder(node->left);
//Print node value
printf(" %d",node->data);
inorder(node->right);
}
}
int main(){
struct Node*root=NULL;
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \
13 12 11
*/
//Insertion of binary tree nodes
root =insert(1);
root->left =insert(5);
root->right =insert(6);
root->right->right =insert(10);
root->right->left =insert(8);
root->left->left =insert(9);
root->left->left->left =insert(13);
root->left->right =insert(7);
root->left->right->right =insert(11);
root->left->right->left =insert(12);
inorder(root);
if(is_min_heap(root)==1)
{
printf("\n Min heap Binary Tree \n");
}
else
{
printf("\n Not a Min Heap Binary Tree \n");
}
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \ \
13 12 11 2
*/
root->right->right->right = insert(2);
inorder(root);
if(is_min_heap(root)==1)
{
printf("\n Min heap Binary Tree \n");
}
else
{
printf("\n Not a Min Heap Binary Tree \n");
}
return 0;
}
Output
13 9 5 12 7 11 1 8 6 10
Min heap Binary Tree
13 9 5 12 7 11 1 8 6 10 2
Not a Min Heap Binary Tree/*
C++ Program
Check whether binary tree is form of min heap
*/
#include<iostream>
using namespace std;
//Structure of Binary Tree node
class Node {
public:
int data;
Node *left;
Node *right;
//make a tree node
Node(int data) {
//assign field values
this->data = data;
this->left = NULL;
this->right = NULL;
}
};
class MyHeap {
public:
Node *root;
MyHeap() {
this->root = NULL;
}
//Check that given binary tree is form of min heap or not
bool is_min_heap(Node *root) {
if (root != NULL) {
if (root->left != NULL && root->left->data < root->data || root->right != NULL && root->right->data < root->data) {
return
//When tree is not a min heap
false;
}
if (this->is_min_heap(root->left) == true && this->is_min_heap(root->right) == true) {
return
//When the tree is in the form of a min heap
true;
}
return false;
}
return true;
}
//Display tree elements in order form
void inorder(Node *node) {
if (node != NULL) {
this->inorder(node->left);
//Print node value
cout << " " << node->data;
this->inorder(node->right);
}
}
};
int main() {
MyHeap obj = MyHeap();
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \
13 12 11
*/
//Insertion of binary tree nodes
obj.root = new Node(1);
obj.root->left = new Node(5);
obj.root->right = new Node(6);
obj.root->right->right = new Node(10);
obj.root->right->left = new Node(8);
obj.root->left->left = new Node(9);
obj.root->left->left->left = new Node(13);
obj.root->left->right = new Node(7);
obj.root->left->right->right = new Node(11);
obj.root->left->right->left = new Node(12);
obj.inorder(obj.root);
if (obj.is_min_heap(obj.root) == true) {
cout << "\n Min heap Binary Tree \n";
} else {
cout << "\n Not a Min Heap Binary Tree \n";
}
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \ \
13 12 11 2
*/
obj.root->right->right->right = new Node(2);
obj.inorder(obj.root);
if (obj.is_min_heap(obj.root) == true) {
cout << "\n Min heap Binary Tree \n";
} else {
cout << "\n Not a Min Heap Binary Tree \n";
}
return 0;
}
Output
13 9 5 12 7 11 1 8 6 10
Min heap Binary Tree
13 9 5 12 7 11 1 8 6 10 2
Not a Min Heap Binary Tree/*
Java Program
Check whether binary tree is form of min heap
*/
//Structure of Binary Tree node
class Node {
public int data;
public Node left;
public Node right;
//make a tree node
public Node(int data) {
//assign field values
this.data = data;
left = null;
right = null;
}
}
public class MyHeap {
public Node root;
public MyHeap() {
root = null;
}
//Check that given binary tree is form of min heap or not
public boolean is_min_heap(Node root) {
if (root != null) {
if (root.left != null && root.left.data < root.data ||
root.right != null && root.right.data < root.data) {
//When tree is not a min heap
return false;
}
if (is_min_heap(root.left) == true && is_min_heap(root.right) == true) {
//When the tree is in the form of a min heap
return true;
}
return false;
}
return true;
}
//Display tree elements in order form
public void inorder(Node node) {
if (node != null) {
inorder(node.left);
//Print node value
System.out.print(" "+ node.data);
inorder(node.right);
}
}
public static void main(String[] args) {
MyHeap obj = new MyHeap();
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \
13 12 11
*/
//Insertion of binary tree nodes
obj.root = new Node(1);
obj.root.left = new Node(5);
obj.root.right = new Node(6);
obj.root.right.right = new Node(10);
obj.root.right.left = new Node(8);
obj.root.left.left = new Node(9);
obj.root.left.left.left = new Node(13);
obj.root.left.right = new Node(7);
obj.root.left.right.right = new Node(11);
obj.root.left.right.left = new Node(12);
obj.inorder(obj.root);
if (obj.is_min_heap(obj.root) == true) {
System.out.print("\n Min heap Binary Tree \n");
} else {
System.out.print("\n Not a Min Heap Binary Tree \n");
}
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \ \
13 12 11 2
*/
obj.root.right.right.right = new Node(2);
obj.inorder(obj.root);
if (obj.is_min_heap(obj.root) == true) {
System.out.print("\n Min heap Binary Tree \n");
} else {
System.out.print("\n Not a Min Heap Binary Tree \n");
}
}
}
Output
13 9 5 12 7 11 1 8 6 10
Min heap Binary Tree
13 9 5 12 7 11 1 8 6 10 2
Not a Min Heap Binary Tree/*
C# Program
Check whether binary tree is form of min heap
*/
using System;
//Structure of Binary Tree node
public class Node {
public int data;
public Node left;
public Node right;
//make a tree node
public Node(int data) {
//assign field values
this.data = data;
left = null;
right = null;
}
}
public class MyHeap {
public Node root;
public MyHeap() {
root = null;
}
//Check that given binary tree is form of min heap or not
public Boolean is_min_heap(Node root) {
if (root != null) {
if (root.left != null && root.left.data < root.data || root.right != null && root.right.data < root.data) {
return false;
}
if (is_min_heap(root.left) == true && is_min_heap(root.right) == true) {
return true;
}
return false;
}
return true;
}
//Display tree elements in order form
public void inorder(Node node) {
if (node != null) {
inorder(node.left);
Console.Write(" " + node.data);
inorder(node.right);
}
}
public static void Main(String[] args) {
MyHeap obj = new MyHeap();
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \
13 12 11
*/
//Insertion of binary tree nodes
obj.root = new Node(1);
obj.root.left = new Node(5);
obj.root.right = new Node(6);
obj.root.right.right = new Node(10);
obj.root.right.left = new Node(8);
obj.root.left.left = new Node(9);
obj.root.left.left.left = new Node(13);
obj.root.left.right = new Node(7);
obj.root.left.right.right = new Node(11);
obj.root.left.right.left = new Node(12);
obj.inorder(obj.root);
if (obj.is_min_heap(obj.root) == true) {
Console.Write("\n Min heap Binary Tree \n");
} else {
Console.Write("\n Not a Min Heap Binary Tree \n");
}
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \ \
13 12 11 2
*/
obj.root.right.right.right = new Node(2);
obj.inorder(obj.root);
if (obj.is_min_heap(obj.root) == true) {
Console.Write("\n Min heap Binary Tree \n");
} else {
Console.Write("\n Not a Min Heap Binary Tree \n");
}
}
}
Output
13 9 5 12 7 11 1 8 6 10
Min heap Binary Tree
13 9 5 12 7 11 1 8 6 10 2
Not a Min Heap Binary Tree<?php
/*
Php Program
Check whether binary tree is form of min heap
*/
//Structure of Binary Tree node
class Node {
public $data;
public $left;
public $right;
//make a tree node
function __construct($data) {
//assign field values
$this->data = $data;
$this->left = null;
$this->right = null;
}
}
class MyHeap {
public $root;
function __construct() {
$this->root = null;
}
//Check that given binary tree is form of min heap or not
public function is_min_heap($root) {
if ($root != null) {
if ($root->left != null && $root->left->data < $root->data || $root->right != null && $root->right->data < $root->data) {
return false;
}
if ($this->is_min_heap($root->left) == true && $this->is_min_heap($root->right) == true) {
return true;
}
return false;
}
return true;
}
//Display tree elements in order form
public function inorder($node) {
if ($node != null) {
$this->inorder($node->left);
//Print node value
echo(" ". $node->data);
$this->inorder($node->right);
}
}
}
function main() {
$obj = new MyHeap();
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \
13 12 11
*/
//Insertion of binary tree nodes
$obj->root = new Node(1);
$obj->root->left = new Node(5);
$obj->root->right = new Node(6);
$obj->root->right->right = new Node(10);
$obj->root->right->left = new Node(8);
$obj->root->left->left = new Node(9);
$obj->root->left->left->left = new Node(13);
$obj->root->left->right = new Node(7);
$obj->root->left->right->right = new Node(11);
$obj->root->left->right->left = new Node(12);
$obj->inorder($obj->root);
if (
$obj->is_min_heap($obj->root) == true) {
echo("\n Min heap Binary Tree \n");
} else {
echo("\n Not a Min Heap Binary Tree \n");
}
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \ \
13 12 11 2
*/
$obj->root->right->right->right = new Node(2);
$obj->inorder($obj->root);
if (
$obj->is_min_heap($obj->root) == true) {
echo("\n Min heap Binary Tree \n");
} else {
echo("\n Not a Min Heap Binary Tree \n");
}
}
main();
Output
13 9 5 12 7 11 1 8 6 10
Min heap Binary Tree
13 9 5 12 7 11 1 8 6 10 2
Not a Min Heap Binary Tree/*
Node Js Program
Check whether binary tree is form of min heap
*/
//Structure of Binary Tree node
class Node {
//make a tree node
constructor(data) {
//assign field values
this.data = data;
this.left = null;
this.right = null;
}
}
class MyHeap {
constructor() {
this.root = null;
}
//Check that given binary tree is form of min heap or not
is_min_heap(root) {
if (root != null) {
if (root.left != null && root.left.data < root.data || root.right != null && root.right.data < root.data) {
return false;
}
if (this.is_min_heap(root.left) == true && this.is_min_heap(root.right) == true) {
return true;
}
return false;
}
return true;
}
//Display tree elements in order form
inorder(node) {
if (node != null) {
this.inorder(node.left);
//Print node value
process.stdout.write(" " + node.data);
this.inorder(node.right);
}
}
}
function main(args) {
var obj = new MyHeap();
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \
13 12 11
*/
//Insertion of binary tree nodes
obj.root = new Node(1);
obj.root.left = new Node(5);
obj.root.right = new Node(6);
obj.root.right.right = new Node(10);
obj.root.right.left = new Node(8);
obj.root.left.left = new Node(9);
obj.root.left.left.left = new Node(13);
obj.root.left.right = new Node(7);
obj.root.left.right.right = new Node(11);
obj.root.left.right.left = new Node(12);
obj.inorder(obj.root);
if (obj.is_min_heap(obj.root) == true) {
process.stdout.write("\n Min heap Binary Tree \n");
} else {
process.stdout.write("\n Not a Min Heap Binary Tree \n");
}
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \ \
13 12 11 2
*/
obj.root.right.right.right = new Node(2);
obj.inorder(obj.root);
if (obj.is_min_heap(obj.root) == true) {
process.stdout.write("\n Min heap Binary Tree \n");
} else {
process.stdout.write("\n Not a Min Heap Binary Tree \n");
}
}
main();
Output
13 9 5 12 7 11 1 8 6 10
Min heap Binary Tree
13 9 5 12 7 11 1 8 6 10 2
Not a Min Heap Binary Tree# Python 3 Program
# Check whether binary tree is form of min heap
# Structure of Binary Tree node
class Node :
# make a tree node
def __init__(self, data) :
# assign field values
self.data = data
self.left = None
self.right = None
class MyHeap :
def __init__(self) :
self.root = None
# Check that given binary tree is form of min heap or not
def is_min_heap(self, root) :
if (root != None) :
if (root.left != None and root.left.data < root.data or
root.right != None and root.right.data < root.data) :
return False
if (self.is_min_heap(root.left) == True and
self.is_min_heap(root.right) == True) :
return True
return False
return True
# Display tree elements in order form
def inorder(self, node) :
if (node != None) :
self.inorder(node.left)
print(" ", node.data, end = "")
self.inorder(node.right)
def main() :
obj = MyHeap()
# Make A Binary Tree
# -----------------------
# 1
# / \
# 5 6
# / \ / \
# 9 7 8 10
# / / \
# 13 12 11
#
#
#
# Insertion of binary tree nodes
obj.root = Node(1)
obj.root.left = Node(5)
obj.root.right = Node(6)
obj.root.right.right = Node(10)
obj.root.right.left = Node(8)
obj.root.left.left = Node(9)
obj.root.left.left.left = Node(13)
obj.root.left.right = Node(7)
obj.root.left.right.right = Node(11)
obj.root.left.right.left = Node(12)
obj.inorder(obj.root)
if (obj.is_min_heap(obj.root) == True) :
print("\n Min heap Binary Tree \n", end = "")
else :
print("\n Not a Min Heap Binary Tree \n", end = "")
# Make A Binary Tree
# -----------------------
# 1
# / \
# 5 6
# / \ / \
# 9 7 8 10
# / / \ \
# 13 12 11 2
#
obj.root.right.right.right = Node(2)
obj.inorder(obj.root)
if (obj.is_min_heap(obj.root) == True) :
print("\n Min heap Binary Tree \n", end = "")
else :
print("\n Not a Min Heap Binary Tree \n", end = "")
if __name__ == "__main__":
main()
Output
13 9 5 12 7 11 1 8 6 10
Min heap Binary Tree
13 9 5 12 7 11 1 8 6 10 2
Not a Min Heap Binary Tree# Ruby Program
# Check whether binary tree is form of min heap
# Structure of Binary Tree node
class Node
# Define the accessor and reader of class Node
attr_reader :data, :left, :right
attr_accessor :data, :left, :right
# make a tree node
def initialize(data)
# assign field values
self.data = data
@left = nil
@right = nil
end
end
class MyHeap
# Define the accessor and reader of class MyHeap
attr_reader :root
attr_accessor :root
def initialize()
@root = nil
end
# Check that given binary tree is form of min heap or not
def is_min_heap(root)
if (root != nil)
if (root.left != nil && root.left.data < root.data || root.right != nil && root.right.data < root.data)
return false
end
if (self.is_min_heap(root.left) == true && self.is_min_heap(root.right) == true)
return true
end
return false
end
return true
end
# Display tree elements in order form
def inorder(node)
if (node != nil)
self.inorder(node.left)
# Print node value
print(" ", node.data)
self.inorder(node.right)
end
end
end
def main()
obj = MyHeap.new()
# Make A Binary Tree
# -----------------------
# 1
# / \
# 5 6
# / \ / \
# 9 7 8 10
# / / \
# 13 12 11
#
#
#
# Insertion of binary tree nodes
obj.root = Node.new(1)
obj.root.left = Node.new(5)
obj.root.right = Node.new(6)
obj.root.right.right = Node.new(10)
obj.root.right.left = Node.new(8)
obj.root.left.left = Node.new(9)
obj.root.left.left.left = Node.new(13)
obj.root.left.right = Node.new(7)
obj.root.left.right.right = Node.new(11)
obj.root.left.right.left = Node.new(12)
obj.inorder(obj.root)
if (obj.is_min_heap(obj.root) == true)
print("\n Min heap Binary Tree \n")
else
print("\n Not a Min Heap Binary Tree \n")
end
# Make A Binary Tree
# -----------------------
# 1
# / \
# 5 6
# / \ / \
# 9 7 8 10
# / / \ \
# 13 12 11 2
#
obj.root.right.right.right = Node.new(2)
obj.inorder(obj.root)
if (obj.is_min_heap(obj.root) == true)
print("\n Min heap Binary Tree \n")
else
print("\n Not a Min Heap Binary Tree \n")
end
end
main()
Output
13 9 5 12 7 11 1 8 6 10
Min heap Binary Tree
13 9 5 12 7 11 1 8 6 10 2
Not a Min Heap Binary Tree
/*
Scala Program
Check whether binary tree is form of min heap
*/
//Structure of Binary Tree node
//Structure of Binary Tree node
class Node(var data: Int,var left: Node,var right: Node) {
//make a tree node
def this(data: Int) {
//assign field values
this(data, null,null);
}
}
class MyHeap(var root: Node) {
def this() {
this(null);
}
//Check that given binary tree is form of min heap or not
def is_min_heap(root: Node): Boolean = {
if (root != null) {
if (root.left != null && root.left.data < root.data || root.right != null && root.right.data < root.data) {
return false;
}
if (this.is_min_heap(root.left) == true && this.is_min_heap(root.right) == true) {
return true;
}
return false;
}
return true;
}
//Display tree elements in order form
def inorder(node: Node): Unit = {
if (node != null) {
this.inorder(node.left);
//Print node value
print(" " + node.data);
this.inorder(node.right);
}
}
}
object Main {
def main(args: Array[String]): Unit = {
val obj: MyHeap = new MyHeap();
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \
13 12 11
*/
//Insertion of binary tree nodes
obj.root = new Node(1);
obj.root.left = new Node(5);
obj.root.right = new Node(6);
obj.root.right.right = new Node(10);
obj.root.right.left = new Node(8);
obj.root.left.left = new Node(9);
obj.root.left.left.left = new Node(13);
obj.root.left.right = new Node(7);
obj.root.left.right.right = new Node(11);
obj.root.left.right.left = new Node(12);
obj.inorder(obj.root);
if (obj.is_min_heap(obj.root) == true) {
print("\n Min heap Binary Tree \n");
} else {
print("\n Not a Min Heap Binary Tree \n");
}
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \ \
13 12 11 2
*/
obj.root.right.right.right = new Node(2);
obj.inorder(obj.root);
if (obj.is_min_heap(obj.root) == true) {
print("\n Min heap Binary Tree \n");
} else {
print("\n Not a Min Heap Binary Tree \n");
}
}
}
Output
13 9 5 12 7 11 1 8 6 10
Min heap Binary Tree
13 9 5 12 7 11 1 8 6 10 2
Not a Min Heap Binary Tree/*
Swift Program
Check whether binary tree is form of min heap
*/
//Structure of Binary Tree node
class Node {
var data: Int;
var left: Node?;
var right: Node?;
//make a tree node
init(_ data: Int) {
//assign field values
self.data = data;
self.left = nil;
self.right = nil;
}
}
class MyHeap {
var root: Node?;
init() {
self.root = nil;
}
//Check that given binary tree is form of min heap or not
func is_min_heap(_ root: Node?) -> Bool {
if (root != nil) {
if (root!.left != nil && root!.left!.data < root!.data || root!.right != nil && root!.right!.data < root!.data) {
return false;
}
if (self.is_min_heap(root!.left) == true && self.is_min_heap(root!.right) == true) {
return true;
}
return false;
}
return true;
}
//Display tree elements in order form
func inorder(_ node: Node?) {
if (node != nil) {
self.inorder(node!.left);
print(" ", node!.data, terminator: "");
self.inorder(node!.right);
}
}
}
func main() {
let obj: MyHeap = MyHeap();
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \
13 12 11
*/
//Insertion of binary tree nodes
obj.root = Node(1);
obj.root!.left = Node(5);
obj.root!.right = Node(6);
obj.root!.right!.right = Node(10);
obj.root!.right!.left = Node(8);
obj.root!.left!.left = Node(9);
obj.root!.left!.left!.left = Node(13);
obj.root!.left!.right = Node(7);
obj.root!.left!.right!.right = Node(11);
obj.root!.left!.right!.left = Node(12);
obj.inorder(obj.root);
if (obj.is_min_heap(obj.root) == true) {
print("\n Min heap Binary Tree \n", terminator: "");
} else {
print("\n Not a Min Heap Binary Tree \n", terminator: "");
}
/*
Make A Binary Tree
-----------------------
1
/ \
5 6
/ \ / \
9 7 8 10
/ / \ \
13 12 11 2
*/
obj.root!.right!.right!.right = Node(2);
obj.inorder(obj.root);
if (obj.is_min_heap(obj.root) == true) {
print("\n Min heap Binary Tree \n", terminator: "");
} else {
print("\n Not a Min Heap Binary Tree \n", terminator: "");
}
}
main();
Output
13 9 5 12 7 11 1 8 6 10
Min heap Binary Tree
13 9 5 12 7 11 1 8 6 10 2
Not a Min Heap Binary Tree
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