Find minimum element in max heap

Here given code implementation process.

//C Program
//Find minimum element in max heap
#include <stdio.h>

void print_data(int heap[],int size)
{
  
  for(int i = 0; i < size; i++)
  {
    printf(" %d ",heap[i] );
  }
  printf("\n");
}
int find_min(int heap[],int ans, int index,int size)
{
  if((heap[index*2+1]) < ans )
  {
    return heap[index*2+1];
  }
  else if((heap[index*2+2]) < ans)
  {
    return heap[index*2+2];
  }
  return ans;
 
}
void min_element(int heap[],int size)
{
  //Assign initial first element
  int min_node = heap[size/2]; 

  for (int i = (size/2)-1; i >= 0; i--)
  {
    min_node = find_min(heap,min_node,i,size);
  }
  printf("  Min : %d\n",min_node );
}
 int main()
 {

  /*
           10
         /   \
        9     8
       / \   / \ 
      7   4 3   1
     / \  
    6   2

  */
  //max heap array elements
  int heap[] = {10,  9,  8,  7,  4,  3,  1,  6,  2 };

  //Get the size of array
  int size = sizeof(heap)/sizeof(heap[0]);

  print_data(heap,size);
  min_element(heap,size);

  return 0;
}

Output

 10  9  8  7  4  3  1  6  2
  Min : 1
/*
  C++ Program
  Find minimum element in max heap
*/
#include<iostream>
using namespace std;

class MyHeap {
	public:

    //Display heap elements
    void print_data(int heap[], int size) {
      for (int i = 0; i < size; i++) {
        cout << " " << heap[i];
      }
      cout << "\n";
    }
	int find_min(int heap[], int ans, int index, int size) {
		if ((heap[index *2 + 1]) < ans) {
			return heap[index *2 + 1];
		} else
		if ((heap[index *2 + 2]) < ans) {
			return heap[index *2 + 2];
		}
		return ans;
	}
	void min_element(int heap[], int size) {
		if (size <= 0) {
			return;
		}
		//Assign initial first element
		int min_node = heap[size / 2];
		for (int i = (size / 2) - 1; i >= 0; i--) {
			min_node = this->find_min(heap, min_node, i, size);
		}
		cout << " Min : " << min_node << "\n";
	}
};
int main() {
	MyHeap obj = MyHeap();
	int heap[] = {
		10,
		9,
		8,
		7,
		4,
		3,
		1,
		6,
		2
	};
	//Get the size
	int size = sizeof(heap) / sizeof(heap[0]);
	obj.print_data(heap, size);
	obj.min_element(heap, size);
	return 0;
}

Output

 10 9 8 7 4 3 1 6 2
 Min : 1
/*
  Java Program
  Find minimum element in max heap
*/
public class MyHeap {
  //Display heap elements
  public void print_data(int []heap,int size)
  {
    
    for(int i = 0; i < size; i++)
    {
      System.out.print("  "+heap[i] );
    }
    System.out.print("\n");
  }
  public int find_min(int []heap,int ans, int index,int size)
  {
    if((heap[index*2+1]) < ans )
    {
      return heap[index*2+1];
    }
    else if((heap[index*2+2]) < ans)
    {
      return heap[index*2+2];
    }
    return ans;
   
  }
  public void min_element(int []heap,int size)
  {
    if(size<=0)
    {
      return ;
    }
    //Assign initial first element
    int min_node = heap[size/2]; 

    for (int i = (size/2)-1; i >= 0; i--)
    {
      min_node = find_min(heap,min_node,i,size);
    }
    System.out.print("  Min : "+min_node+"\n" );
  }
  public static void main(String[] args) {
    
    MyHeap obj = new MyHeap();
      
    /*
             10
           /   \
          9     8
         / \   / \ 
        7   4 3   1
       / \  
      6   2

    */
    //max heap array elements
    int []heap = {10,  9,  8,  7,  4,  3,  1,  6,  2 };

    //Get the size
    int size = heap.length;
    


    obj.print_data(heap,size);

    obj.min_element(heap,size);
  }
}

Output

 10 9 8 7 4 3 1 6 2
 Min : 1
/*
  C# Program
  Find minimum element in max heap
*/
using System;

public class MyHeap {
	//Display heap elements
	public void print_data(int[] heap, int size) {
		for (int i = 0; i < size; i++) {
			Console.Write(" " + heap[i]);
		}
		Console.Write("\n");
	}
	public int find_min(int[] heap, int ans, int index, int size) {
		if ((heap[index * 2 + 1]) < ans) {
			return heap[index * 2 + 1];
		} else
		if ((heap[index * 2 + 2]) < ans) {
			return heap[index * 2 + 2];
		}
		return ans;
	}
	public void min_element(int[] heap, int size) {
		if (size <= 0) {
			return;
		}
		//Assign initial first element
		int min_node = heap[size / 2];
		for (int i = (size / 2) - 1; i >= 0; i--) {
			min_node = find_min(heap, min_node, i, size);
		}
		Console.Write(" Min : " + min_node + "\n");
	}
	public static void Main(String[] args) {
		MyHeap obj = new MyHeap();
		int[]
		/*
		             10
		           /   \
		          9     8
		         / \   / \ 
		        7   4 3   1
		       / \  
		      6   2

		    */
		//max heap array elements
		heap = {
			10,
			9,
			8,
			7,
			4,
			3,
			1,
			6,
			2
		};
		//Get the size
		int size = heap.Length;
		obj.print_data(heap, size);
		obj.min_element(heap, size);
	}
}

Output

 10 9 8 7 4 3 1 6 2
 Min : 1
<?php
/*
  Php Program
  Find minimum element in max heap
*/
class MyHeap {
	//Display heap elements

	public 	function print_data($heap, $size) {
		for ($i = 0; $i < $size; $i++) {
			echo(" ". $heap[$i]);
		}
		echo("\n");
	}
	public 	function find_min($heap, $ans, $index, $size) {
		if (($heap[$index *2 + 1]) < $ans) {
			return $heap[$index *2 + 1];
		} else
		if (($heap[$index *2 + 2]) < $ans) {
			return $heap[$index *2 + 2];
		}
		return $ans;
	}
	public 	function min_element($heap, $size) {
		if ($size <= 0) {
			return;
		}
		//Assign initial first element
		$min_node = $heap[intval($size / 2)];
		for ($i = (intval($size / 2)) - 1; $i >= 0; $i--) {
			$min_node = $this->find_min($heap, $min_node, $i, $size);
		}
		echo(" Min : ". $min_node ."\n");
	}
}

function main() {
	$obj = new MyHeap();
	/*
	             10
	           /   \
	          9     8
	         / \   / \ 
	        7   4 3   1
	       / \  
	      6   2

	    */
	//max heap array elements
	$heap = array(10, 9, 8, 7, 4, 3, 1, 6, 2);
	//Get the size
	$size = count($heap);
	$obj->print_data($heap, $size);
	$obj->min_element($heap, $size);

}
main();

Output

 10 9 8 7 4 3 1 6 2
 Min : 1
/*
  Node Js Program
  Find minimum element in max heap
*/
class MyHeap {
	//Display heap elements
	print_data(heap, size) {
		for (var i = 0; i < size; i++) {
			process.stdout.write(" " + heap[i]);
		}

		process.stdout.write("\n");
	}
	find_min(heap, ans, index, size) {
		if ((heap[index *2 + 1]) < ans) {
			return heap[index *2 + 1];
		} else
		if ((heap[index *2 + 2]) < ans) {
			return heap[index *2 + 2];
		}

		return ans;
	}
	min_element(heap, size) {
		if (size <= 0) {
			return;
		}

		//Assign initial first element
		var min_node = heap[parseInt(size / 2)];
		for (var i = (parseInt(size / 2)) - 1; i >= 0; i--) {
			min_node = this.find_min(heap, min_node, i, size);
		}

		process.stdout.write(" Min : " + min_node + "\n");
	}
}

function main(args) {
	var obj = new MyHeap();
	/*
	             10
	           /   \
	          9     8
	         / \   / \ 
	        7   4 3   1
	       / \  
	      6   2

	    */
	//max heap array elements
	var heap = [10, 9, 8, 7, 4, 3, 1, 6, 2];
	//Get the size
	var size = heap.length;
	obj.print_data(heap, size);
	obj.min_element(heap, size);
}

main();

Output

 10 9 8 7 4 3 1 6 2
 Min : 1
# Python 3 Program
# Find minimum element in max heap
class MyHeap :
	# Display heap elements
	def print_data(self, heap, size) :
		i = 0
		while (i < size) :
			print(" ", heap[i], end = "")
			i += 1
		
		print("\n", end = "")
	
	def find_min(self, heap, ans, index, size) :
		if ((heap[index * 2 + 1]) < ans) :
			return heap[index * 2 + 1]
		elif ((heap[index * 2 + 2]) < ans) :
			return heap[index * 2 + 2]
		
		return ans
	
	def min_element(self, heap, size) :
		if (size <= 0) :
			return
		
		min_node = heap[int(size / 2)]
		i = (int(size / 2)) - 1
		while (i >= 0) :
			min_node = self.find_min(heap, min_node, i, size)
			i -= 1
		
		print("  Min : ", min_node ,"\n", end = "")
	

def main() :
	obj = MyHeap()
	
	#                  10
	#                /   \
	#               9     8
	#              / \   / \ 
	#             7   4 3   1
	#            / \  
	#           6   2
	#         
	# max heap array elements
	heap = [10, 9, 8, 7, 4, 3, 1, 6, 2]
	# Get the size
	size = len(heap)
	obj.print_data(heap, size)
	obj.min_element(heap, size)


if __name__ == "__main__":
	main()

Output

  10  9  8  7  4  3  1  6  2
  Min :  1
# Ruby Program
# Find minimum element in max heap
class MyHeap 
	 # Display heap elements
	def print_data(heap, size) 
		i = 0
		while (i < size) 
			print(" ", heap[i])
			i += 1
		end
		print("\n")
	end
	def find_min(heap, ans, index, size) 
		if ((heap[index * 2 + 1]) < ans) 
			return heap[index * 2 + 1]
		elsif ((heap[index * 2 + 2]) < ans) 
			return heap[index * 2 + 2]
		end
		return ans
	end
	def min_element(heap, size) 
		if (size <= 0) 
			return
		end
		min_node = heap[size / 2]
		i = (size / 2) - 1
		while (i >= 0) 
			min_node = self.find_min(heap, min_node, i, size)
			i -= 1
		end
		print(" Min  : ", min_node ,"\n")
	end
end
def main() 
	obj = MyHeap.new()
	
	#                  10
	#                /   \
	#               9     8
	#              / \   / \ 
	#             7   4 3   1
	#            / \  
	#           6   2
	#         
	 # max heap array elements
	heap = [10, 9, 8, 7, 4, 3, 1, 6, 2]
	 # Get the size
	size = heap.length
	obj.print_data(heap, size)
	obj.min_element(heap, size)
end
main()

Output

 10 9 8 7 4 3 1 6 2
 Min  : 1
/*
  Scala Program
  Find minimum element in max heap
*/
class MyHeap {
	//Display heap elements
	def print_data(heap: Array[Int], size: Int): Unit = {
		var i: Int = 0;
		while (i < size) {
			print(" " + heap(i));
			i += 1;
		}
		print("\n");
	}
	def find_min(heap: Array[Int], ans: Int, index: Int, size: Int): Int = {
		if ((heap(index * 2 + 1)) < ans) {
			return heap(index * 2 + 1);
		} else
		if ((heap(index * 2 + 2)) < ans) {
			return heap(index * 2 + 2);
		}
		return ans;
	}
	def min_element(heap: Array[Int], size: Int): Unit = {
		if (size <= 0) {
			return;
		}
		var min_node: Int = heap((size / 2).toInt);
		var i: Int = ((size / 2).toInt) - 1;
		while (i >= 0) {
			min_node = this.find_min(heap, min_node, i, size);
			i -= 1;
		}
		print(" Min : " + min_node + "\n");
	}
}
object Main {
	def main(args: Array[String]): Unit = {
		val obj: MyHeap = new MyHeap();

		/*
		                 10
		               /   \
		              9     8
		             / \   / \ 
		            7   4 3   1
		           / \  
		          6   2

		        */
		//max heap array elements
		val heap: Array[Int] = Array(10, 9, 8, 7, 4, 3, 1, 6, 2);

		//Get the size
		val size: Int = heap.length;
		obj.print_data(heap, size);
		obj.min_element(heap, size);
	}
}

Output

 10 9 8 7 4 3 1 6 2
 Min : 1
/*
  Swift Program
  Find minimum element in max heap
*/
class MyHeap {
	//Display heap elements
	func print_data(_ heap: [Int], _ size: Int) {
		var i = 0;
		while (i < size) {
			print(" ", heap[i], terminator: "");
			i += 1;
		}
		print("\n", terminator: "");
	}
	func find_min(_ heap: [Int], _ ans: Int, _ index: Int, _ size: Int) -> Int {
		if ((heap[index * 2 + 1]) < ans) {
			return heap[index * 2 + 1];
		} else
		if ((heap[index * 2 + 2]) < ans) {
			return heap[index * 2 + 2];
		}
		return ans;
	}
	func min_element(_ heap: [Int], _ size: Int) {
		if (size <= 0) {
			return;
		}
		var min_node = heap[size / 2];
		var i = (size / 2) - 1;
		while (i >= 0) {
			min_node = self.find_min(heap, min_node, i, size);
			i -= 1;
		}
		print("  Min : ", min_node ,"\n", terminator: "");
	}
}
func main() {
	let obj = MyHeap();
	/*
	                 10
	               /   \
	              9     8
	             / \   / \ 
	            7   4 3   1
	           / \  
	          6   2

	*/
	//max heap array elements
	let heap = [10, 9, 8, 7, 4, 3, 1, 6, 2];
	//Get the size
	let size = heap.count;
	obj.print_data(heap, size);
	obj.min_element(heap, size);
}
main();

Output

  10  9  8  7  4  3  1  6  2
  Min :  1


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







© 2021, kalkicode.com, All rights reserved