K-ary Heap

Here given code implementation process.

/*
  C Program 
  K-ary Heap
*/

#include <stdio.h>
#include <stdlib.h>

struct KAryHeap
{
    int limit; // Number of element
    int n; // Current element
    int k ; // Number of child
    int *collection;
};

// Returns a new heap
struct KAryHeap* newHeap(int limit, int k)
{
    struct KAryHeap* heap = (struct KAryHeap*)malloc(sizeof(struct KAryHeap));
    if(heap==NULL)
    {
        printf("\n Memory Overflow, when creating new heap\n");
        return NULL;
    }
    // Set How many number of elements possible in heap
    heap->limit = limit;

    // Set intial no element in heap
    heap->n = 0;

    // Set number of child nodes
    heap->k = k;

    // Allocate memory of heap elements
    heap->collection = (int *)calloc(limit,sizeof(int));

    if(heap->collection == NULL)
    {
        printf("\n Memory Overflow, when creating new heap collection\n");
    }

    return heap;
}

// Display pre order view of ternary tree
void preorder(struct KAryHeap*heap, int root)
{
    if ( root < heap->n)
    {
        printf("  %d", heap->collection[root]);
        // Recursive visit to child node
        for (int i = 1; i <= heap->k; ++i)
        {
            preorder(heap,heap->k *root + i);
        }
    }
}


// Swap two elements of heap collection
void swap(struct KAryHeap*heap, int first, int second)
{
    int auxiliary = heap->collection[first];
    heap->collection[first] = heap->collection[second];
    heap->collection[second] = auxiliary;
}

// This are converting tree into valid max heap when insert new element
void putElement(struct KAryHeap*heap, int location) 
{ 
    int root = (location-1)/heap->k; 
  
    while (root >= 0 && heap->collection[location] > heap->collection[root]) 
    { 
        swap(heap, location, root); 
        location = root; 
        root = (location-1)/heap->k; 
    } 
} 
// Handles the request of adding  new heap element
void addElement(struct KAryHeap*heap, int data)
{
    if(heap->n+1 >= heap->limit)
    {
        printf("\n Heap limit is exceeded When add new element");
        return;
    }
    heap->collection[heap->n] = data;
    heap->n = heap->n + 1;
    putElement(heap, heap->n-1);  
}




// After remove top of tree this are converted into a new max heap
void changeElement(struct KAryHeap*heap, int location)
{
    int update = -1;
    for (int i = 1; i <= heap->k; ++i)
    {
        if((location*heap->k)+i < heap->n && heap->collection[location] < 
            heap->collection[(location*heap->k)+i])

        {
            if(update == -1)
            {
                // First largest child
                update = (location*heap->k)+i;
            }
            else if(heap->collection[update] < heap->collection[(location*heap->k)+i])
            {
                // When previous child is smaller
                update = (location*heap->k)+i;
            }
        }
    }

    if(update >= 0)
    {
        // Swap element
        swap(heap,location,update);
        // Check next updation
        changeElement(heap,update);
    }
}
// Remove the max element from the tree
int extractMax(struct KAryHeap*heap) 
{
    if(heap->n == 0)
    {
        printf("\n Empty Heap ");
        return -1;
    }
    int element = heap->collection[0];

    heap->collection[0] = heap->collection[heap->n-1];

    heap->collection[heap->n-1] = 0;

    heap->n = heap->n - 1;

    changeElement(heap, 0); 

    return element;
}

// Handles the request of displaying Tree elements
void printTree(struct KAryHeap*heap)
{   
    printf("\n Level Order Heap Element  \n"); 
   
    for (int i=0; i < heap->n; i++) 
    {
        printf("  %d", heap->collection[i]); 
    }
    printf("\n Preorder \n");
    preorder(heap,0);
}

int main()
{

    // Number of elements in heap
    // Set limit
    int limit = 50; 
    // Possible child
    int k = 4;

    struct KAryHeap*heap = newHeap(limit,k);

    // Add heap element
    addElement(heap,10);
    addElement(heap,7);
    addElement(heap,40);
    addElement(heap,2);
    addElement(heap,5);
    addElement(heap,15);
    addElement(heap,21);
    addElement(heap,35);
    addElement(heap,49);
    addElement(heap,38);
    addElement(heap,63);
    addElement(heap,19);

    /* Max heap of K 4
    -----------------------   
    

                       63
        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
        │               │       │    │ 
        40              49      2    5
        |               │
    ┌‒‒‒┬‒‒‒┬‒‒‒┐   ┌‒‒‒┬‒‒‒┐
    │   │   │   │   │   │   │    
    7  15   21  35  10  38  19
    -------------------------------
            Constructed Tree               
    */
    printTree(heap);

    printf("\n Extract Max Element : %d",extractMax(heap));

    /*  Extract Max Element
    -----------------------   
    

                       (49)
        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
        │               │       │    │ 
      (40)             (38)     2    5
        |               │
    ┌‒‒‒┬‒‒‒┬‒‒‒┐     ┌‒‒‒┐
    │   │   │   │     │   │      
    7  15   21  35    10  19  
    -------------------------------
            After remove max node              
    */
    printTree(heap);
    return 0;
}

Output

 Level Order Heap Element
  63  40  49  2  5  7  15  21  35  10  38  19
 Preorder
  63  40  7  15  21  35  49  10  38  19  2  5
 Extract Max Element : 63
 Level Order Heap Element
  49  40  38  2  5  7  15  21  35  10  19
 Preorder
  49  40  7  15  21  35  38  10  19  2  5
/*
    Java program
    K-ary Heap
*/
public class KAryHeap
{
	public int limit;
	// Number of element
	public int n;
	// Current element
	public int k;
	// Number of child
	public int[] collection;
	public KAryHeap(int limit, int k)
	{
		// Set How many number of elements possible in heap
		this.limit = limit;
		// Set intial no element in heap
		this.n = 0;
		// Set number of child nodes
		this.k = k;
		// Allocate memory of heap elements
		this.collection = new int[limit];
	}
	// Display pre order view of ternary tree
	public void preorder(int root)
	{
		if (root < this.n)
		{
			System.out.print("  " + this.collection[root]);
			// Recursive visit to child node
			for (int i = 1; i <= this.k; ++i)
			{
				preorder(this.k * root + i);
			}
		}
	}
	// Swap two elements of heap collection
	public void swap(int first, int second)
	{
		int auxiliary = this.collection[first];
		this.collection[first] = this.collection[second];
		this.collection[second] = auxiliary;
	}
	// This are converting tree into valid max heap when insert new element
	public void putElement(int location)
	{
		int root = (location - 1) / this.k;
		while (root >= 0 && this.collection[location] > this.collection[root])
		{
			swap(location, root);
			location = root;
			root = (location - 1) / this.k;
		}
	}
	// Handles the request of adding  new heap element
	public void addElement(int data)
	{
		if (this.n + 1 >= this.limit)
		{
			System.out.print("\n Heap limit is exceeded When add new element");
			return;
		}
		this.collection[this.n] = data;
		this.n = this.n + 1;
		putElement(this.n - 1);
	}
	// After remove top of tree this are converted into a new max heap
	public void changeElement(int location)
	{
		int update = -1;
		for (int i = 1; i <= this.k; ++i)
		{
			if ((location * this.k) + i < this.n && this.collection[location] < this.collection[(location * this.k) + i])
			{
				if (update == -1)
				{
					// First largest child
					update = (location * this.k) + i;
				}
				else if (this.collection[update] < this.collection[(location * this.k) + i])
				{
					// When previous child is smaller
					update = (location * this.k) + i;
				}
			}
		}
		if (update >= 0)
		{
			// Swap element
			swap(location, update);
			// Check next updation
			changeElement(update);
		}
	}
	// Remove the max element from the tree
	public int extractMax()
	{
		if (this.n == 0)
		{
			System.out.print("\n Empty Heap ");
			return -1;
		}
		int element = this.collection[0];
		this.collection[0] = this.collection[this.n - 1];
		this.collection[this.n - 1] = 0;
		this.n = this.n - 1;
		changeElement(0);
		return element;
	}
	// Handles the request of displaying Tree elements
	public void printTree()
	{
		System.out.print("\n Level Order Heap Element \n");
		for (int i = 0; i < this.n; i++)
		{
			System.out.print("  " + this.collection[i]);
		}
		System.out.print("\n Preorder \n");
		preorder(0);
	}
	public static void main(String[] args)
	{
		// Number of elements in heap
		// Set limit
		int limit = 50;
		// Possible child
		int k = 4;
		KAryHeap heap = new KAryHeap(limit, k);
		// Add heap element
		heap.addElement(10);
		heap.addElement(7);
		heap.addElement(40);
		heap.addElement(2);
		heap.addElement(5);
		heap.addElement(15);
		heap.addElement(21);
		heap.addElement(35);
		heap.addElement(49);
		heap.addElement(38);
		heap.addElement(63);
		heap.addElement(19);
		/*Max heap of K 4
		        -----------------------   
		        
		                       63
		        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
		        │               │       │    │ 
		        40              49      2    5
		        |               │
		    ┌‒‒‒┬‒‒‒┬‒‒‒┐   ┌‒‒‒┬‒‒‒┐
		    │   │   │   │   │   │   │    
		    7  15   21  35  10  38  19
		    -------------------------------
		            Constructed Tree               
		        
		*/
		heap.printTree();
		System.out.print("\n Extract Max Element : " + heap.extractMax());
		/* Extract Max Element
		  -----------------------   
		    
		                       (49)
		        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
		        │               │       │    │ 
		      (40)             (38)     2    5
		        |               │
		    ┌‒‒‒┬‒‒‒┬‒‒‒┐     ┌‒‒‒┐
		    │   │   │   │     │   │      
		    7  15   21  35    10  19  
		    -------------------------------
		            After remove max node              
		        
		*/
		heap.printTree();
	}
}

Output

 Level Order Heap Element
  63  40  49  2  5  7  15  21  35  10  38  19
 Preorder
  63  40  7  15  21  35  49  10  38  19  2  5
 Extract Max Element : 63
 Level Order Heap Element
  49  40  38  2  5  7  15  21  35  10  19
 Preorder
  49  40  7  15  21  35  38  10  19  2  5
// Include header file
#include <iostream>

using namespace std;
/*
    C++ program
    K-ary Heap
*/
class KAryHeap
{
	public: int limit;
	// Number of element
	int n;
	// Current element
	int k;
	// Number of child
	int *collection;
	KAryHeap(int limit, int k)
	{
		// Set How many number of elements possible in heap
		this->limit = limit;
		// Set intial no element in heap
		this->n = 0;
		// Set number of child nodes
		this->k = k;
		// Allocate memory of heap elements
		this->collection = new int[limit];
	}
	// Display pre order view of ternary tree
	void preorder(int root)
	{
		if (root < this->n)
		{
			cout << "  " << this->collection[root];
			// Recursive visit to child node
			for (int i = 1; i <= this->k; ++i)
			{
				this->preorder(this->k *root + i);
			}
		}
	}
	// Swap two elements of heap collection
	void swap(int first, int second)
	{
		int auxiliary = this->collection[first];
		this->collection[first] = this->collection[second];
		this->collection[second] = auxiliary;
	}
	// This are converting tree into valid max heap when insert new element
	void putElement(int location)
	{
		int root = (location - 1) / this->k;
		while (root >= 0 && this->collection[location] > this->collection[root])
		{
			this->swap(location, root);
			location = root;
			root = (location - 1) / this->k;
		}
	}
	// Handles the request of adding  new heap element
	void addElement(int data)
	{
		if (this->n + 1 >= this->limit)
		{
			cout << "\n Heap limit is exceeded When add new element";
			return;
		}
		this->collection[this->n] = data;
		this->n = this->n + 1;
		this->putElement(this->n - 1);
	}
	// After remove top of tree this are converted into a new max heap
	void changeElement(int location)
	{
		int update = -1;
		for (int i = 1; i <= this->k; ++i)
		{
			if ((location *this->k) + i < this->n && this->collection[location] < this->collection[(location *this->k) + i])
			{
				if (update == -1)
				{
					// First largest child
					update = (location *this->k) + i;
				}
				else if (this->collection[update] < this->collection[(location *this->k) + i])
				{
					// When previous child is smaller
					update = (location *this->k) + i;
				}
			}
		}
		if (update >= 0)
		{
			// Swap element
			this->swap(location, update);
			// Check next updation
			this->changeElement(update);
		}
	}
	// Remove the max element from the tree
	int extractMax()
	{
		if (this->n == 0)
		{
			cout << "\n Empty Heap ";
			return -1;
		}
		int element = this->collection[0];
		this->collection[0] = this->collection[this->n - 1];
		this->collection[this->n - 1] = 0;
		this->n = this->n - 1;
		this->changeElement(0);
		return element;
	}
	// Handles the request of displaying Tree elements
	void printTree()
	{
		cout << "\n Level Order Heap Element \n";
		for (int i = 0; i < this->n; i++)
		{
			cout << "  " << this->collection[i];
		}
		cout << "\n Preorder \n";
		this->preorder(0);
	}
};
int main()
{
	// Number of elements in heap
	// Set limit
	int limit = 50;
	// Possible child
	int k = 4;
	KAryHeap heap = KAryHeap(limit, k);
	// Add heap element
	heap.addElement(10);
	heap.addElement(7);
	heap.addElement(40);
	heap.addElement(2);
	heap.addElement(5);
	heap.addElement(15);
	heap.addElement(21);
	heap.addElement(35);
	heap.addElement(49);
	heap.addElement(38);
	heap.addElement(63);
	heap.addElement(19);
	/*Max heap of K 4
	        -----------------------   
	        
	                       63
	        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
	        │               │       │    │ 
	        40              49      2    5
	        |               │
	    ┌‒‒‒┬‒‒‒┬‒‒‒┐   ┌‒‒‒┬‒‒‒┐
	    │   │   │   │   │   │   │    
	    7  15   21  35  10  38  19
	    -------------------------------
	            Constructed Tree               
	        
	*/
	heap.printTree();
	cout << "\n Extract Max Element : " << heap.extractMax();
	/*Extract Max Element
	  -----------------------   
	    
	                       (49)
	        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
	        │               │       │    │ 
	      (40)             (38)     2    5
	        |               │
	    ┌‒‒‒┬‒‒‒┬‒‒‒┐     ┌‒‒‒┐
	    │   │   │   │     │   │      
	    7  15   21  35    10  19  
	    -------------------------------
	            After remove max node              
	        
	*/
	heap.printTree();
	return 0;
}

Output

 Level Order Heap Element
  63  40  49  2  5  7  15  21  35  10  38  19
 Preorder
  63  40  7  15  21  35  49  10  38  19  2  5
 Extract Max Element : 63
 Level Order Heap Element
  49  40  38  2  5  7  15  21  35  10  19
 Preorder
  49  40  7  15  21  35  38  10  19  2  5
// Include namespace system
using System;
/*
    C# program
    K-ary Heap
*/
public class KAryHeap
{
	public int limit;
	// Number of element
	public int n;
	// Current element
	public int k;
	// Number of child
	public int[] collection;
	public KAryHeap(int limit, int k)
	{
		// Set How many number of elements possible in heap
		this.limit = limit;
		// Set intial no element in heap
		this.n = 0;
		// Set number of child nodes
		this.k = k;
		// Allocate memory of heap elements
		this.collection = new int[limit];
	}
	// Display pre order view of ternary tree
	public void preorder(int root)
	{
		if (root < this.n)
		{
			Console.Write("  " + this.collection[root]);
			// Recursive visit to child node
			for (int i = 1; i <= this.k; ++i)
			{
				preorder(this.k * root + i);
			}
		}
	}
	// Swap two elements of heap collection
	public void swap(int first, int second)
	{
		int auxiliary = this.collection[first];
		this.collection[first] = this.collection[second];
		this.collection[second] = auxiliary;
	}
	// This are converting tree into valid max heap when insert new element
	public void putElement(int location)
	{
		int root = (location - 1) / this.k;
		while (root >= 0 && this.collection[location] > this.collection[root])
		{
			swap(location, root);
			location = root;
			root = (location - 1) / this.k;
		}
	}
	// Handles the request of adding  new heap element
	public void addElement(int data)
	{
		if (this.n + 1 >= this.limit)
		{
			Console.Write("\n Heap limit is exceeded When add new element");
			return;
		}
		this.collection[this.n] = data;
		this.n = this.n + 1;
		putElement(this.n - 1);
	}
	// After remove top of tree this are converted into a new max heap
	public void changeElement(int location)
	{
		int update = -1;
		for (int i = 1; i <= this.k; ++i)
		{
			if ((location * this.k) + i < this.n && this.collection[location] < this.collection[(location * this.k) + i])
			{
				if (update == -1)
				{
					// First largest child
					update = (location * this.k) + i;
				}
				else if (this.collection[update] < this.collection[(location * this.k) + i])
				{
					// When previous child is smaller
					update = (location * this.k) + i;
				}
			}
		}
		if (update >= 0)
		{
			// Swap element
			swap(location, update);
			// Check next updation
			changeElement(update);
		}
	}
	// Remove the max element from the tree
	public int extractMax()
	{
		if (this.n == 0)
		{
			Console.Write("\n Empty Heap ");
			return -1;
		}
		int element = this.collection[0];
		this.collection[0] = this.collection[this.n - 1];
		this.collection[this.n - 1] = 0;
		this.n = this.n - 1;
		changeElement(0);
		return element;
	}
	// Handles the request of displaying Tree elements
	public void printTree()
	{
		Console.Write("\n Level Order Heap Element \n");
		for (int i = 0; i < this.n; i++)
		{
			Console.Write("  " + this.collection[i]);
		}
		Console.Write("\n Preorder \n");
		preorder(0);
	}
	public static void Main(String[] args)
	{
		// Number of elements in heap
		// Set limit
		int limit = 50;
		// Possible child
		int k = 4;
		KAryHeap heap = new KAryHeap(limit, k);
		// Add heap element
		heap.addElement(10);
		heap.addElement(7);
		heap.addElement(40);
		heap.addElement(2);
		heap.addElement(5);
		heap.addElement(15);
		heap.addElement(21);
		heap.addElement(35);
		heap.addElement(49);
		heap.addElement(38);
		heap.addElement(63);
		heap.addElement(19);
		/*Max heap of K 4
		        -----------------------   
		        
		                       63
		        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
		        │               │       │    │ 
		        40              49      2    5
		        |               │
		    ┌‒‒‒┬‒‒‒┬‒‒‒┐   ┌‒‒‒┬‒‒‒┐
		    │   │   │   │   │   │   │    
		    7  15   21  35  10  38  19
		    -------------------------------
		            Constructed Tree               
		        
		*/
		heap.printTree();
		Console.Write("\n Extract Max Element : " + heap.extractMax());
		/* Extract Max Element
		  -----------------------   
		    
		                       (49)
		        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
		        │               │       │    │ 
		      (40)             (38)     2    5
		        |               │
		    ┌‒‒‒┬‒‒‒┬‒‒‒┐     ┌‒‒‒┐
		    │   │   │   │     │   │      
		    7  15   21  35    10  19  
		    -------------------------------
		            After remove max node              
		        
		*/
		heap.printTree();
	}
}

Output

 Level Order Heap Element
  63  40  49  2  5  7  15  21  35  10  38  19
 Preorder
  63  40  7  15  21  35  49  10  38  19  2  5
 Extract Max Element : 63
 Level Order Heap Element
  49  40  38  2  5  7  15  21  35  10  19
 Preorder
  49  40  7  15  21  35  38  10  19  2  5
<?php
/*
    Php program
    K-ary Heap
*/
class KAryHeap
{
	public $limit;
	// Number of element
	public $n;
	// Current element
	public $k;
	// Number of child
	public $collection;

	function __construct($limit, $k)
	{
		// Set How many number of elements possible in heap
		$this->limit = $limit;
		// Set intial no element in heap
		$this->n = 0;
		// Set number of child nodes
		$this->k = $k;
		// Allocate memory of heap elements
		$this->collection = array_fill(0, $limit, 0);
	}
	// Display pre order view of ternary tree
	public	function preorder($root)
	{
		if ($root < $this->n)
		{
			echo "  ". $this->collection[$root];
			// Recursive visit to child node
			for ($i = 1; $i <= $this->k; ++$i)
			{
				$this->preorder($this->k * $root + $i);
			}
		}
	}
	// Swap two elements of heap collection
	public	function swap($first, $second)
	{
		$auxiliary = $this->collection[$first];
		$this->collection[$first] = $this->collection[$second];
		$this->collection[$second] = $auxiliary;
	}
	// This are converting tree into valid max heap when insert new element
	public	function putElement($location)
	{
		$root = intval(($location - 1) / $this->k);
		while ($root >= 0 && $this->collection[$location] > $this->collection[$root])
		{
			$this->swap($location, $root);
			$location = $root;
			$root = intval(($location - 1) / $this->k);
		}
	}
	// Handles the request of adding  new heap element
	public	function addElement($data)
	{
		if ($this->n + 1 >= $this->limit)
		{
			echo "\n Heap limit is exceeded When add new element";
			return;
		}
		$this->collection[$this->n] = $data;
		$this->n = $this->n + 1;
		$this->putElement($this->n - 1);
	}
	// After remove top of tree this are converted into a new max heap
	public	function changeElement($location)
	{
		$update = -1;
		for ($i = 1; $i <= $this->k; ++$i)
		{
			if (($location * $this->k) + $i < $this->n && $this->collection[$location] < $this->collection[($location * $this->k) + $i])
			{
				if ($update == -1)
				{
					// First largest child
					$update = ($location * $this->k) + $i;
				}
				else if ($this->collection[$update] < $this->collection[($location * $this->k) + $i])
				{
					// When previous child is smaller
					$update = ($location * $this->k) + $i;
				}
			}
		}
		if ($update >= 0)
		{
			// Swap element
			$this->swap($location, $update);
			// Check next updation
			$this->changeElement($update);
		}
	}
	// Remove the max element from the tree
	public	function extractMax()
	{
		if ($this->n == 0)
		{
			echo "\n Empty Heap ";
			return -1;
		}
		$element = $this->collection[0];
		$this->collection[0] = $this->collection[$this->n - 1];
		$this->collection[$this->n - 1] = 0;
		$this->n = $this->n - 1;
		$this->changeElement(0);
		return $element;
	}
	// Handles the request of displaying Tree elements
	public	function printTree()
	{
		echo "\n Level Order Heap Element \n";
		for ($i = 0; $i < $this->n; $i++)
		{
			echo "  ". $this->collection[$i];
		}
		echo "\n Preorder \n";
		$this->preorder(0);
	}
}

function main()
{
	// Number of elements in heap
	// Set limit
	$limit = 50;
	// Possible child
	$k = 4;
	$heap = new KAryHeap($limit, $k);
	// Add heap element
	$heap->addElement(10);
	$heap->addElement(7);
	$heap->addElement(40);
	$heap->addElement(2);
	$heap->addElement(5);
	$heap->addElement(15);
	$heap->addElement(21);
	$heap->addElement(35);
	$heap->addElement(49);
	$heap->addElement(38);
	$heap->addElement(63);
	$heap->addElement(19);
	/*Max heap of K 4
	        -----------------------   
	        
	                       63
	        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
	        │               │       │    │ 
	        40              49      2    5
	        |               │
	    ┌‒‒‒┬‒‒‒┬‒‒‒┐   ┌‒‒‒┬‒‒‒┐
	    │   │   │   │   │   │   │    
	    7  15   21  35  10  38  19
	    -------------------------------
	            Constructed Tree               
	        
	*/
	$heap->printTree();
	echo "\n Extract Max Element : ". $heap->extractMax();
	/* Extract Max Element
	  -----------------------   
	    
	                       (49)
	        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
	        │               │       │    │ 
	      (40)             (38)     2    5
	        |               │
	    ┌‒‒‒┬‒‒‒┬‒‒‒┐     ┌‒‒‒┐
	    │   │   │   │     │   │      
	    7  15   21  35    10  19  
	    -------------------------------
	            After remove max node              
	        
	*/
	$heap->printTree();
}
main();

Output

 Level Order Heap Element
  63  40  49  2  5  7  15  21  35  10  38  19
 Preorder
  63  40  7  15  21  35  49  10  38  19  2  5
 Extract Max Element : 63
 Level Order Heap Element
  49  40  38  2  5  7  15  21  35  10  19
 Preorder
  49  40  7  15  21  35  38  10  19  2  5
/*
    Node Js program
    K-ary Heap
*/
class KAryHeap
{
	// Number of element
	// Current element
	// Number of child
	constructor(limit, k)
	{
		// Set How many number of elements possible in heap
		this.limit = limit;
		// Set intial no element in heap
		this.n = 0;
		// Set number of child nodes
		this.k = k;
		// Allocate memory of heap elements
		this.collection = Array(limit).fill(0);
	}
	// Display pre order view of ternary tree
	preorder(root)
	{
		if (root < this.n)
		{
			process.stdout.write("  " + this.collection[root]);
			// Recursive visit to child node
			for (var i = 1; i <= this.k; ++i)
			{
				this.preorder(this.k * root + i);
			}
		}
	}
	// Swap two elements of heap collection
	swap(first, second)
	{
		var auxiliary = this.collection[first];
		this.collection[first] = this.collection[second];
		this.collection[second] = auxiliary;
	}
	// This are converting tree into valid max heap when insert new element
	putElement(location)
	{
		var root = parseInt((location - 1) / this.k);
		while (root >= 0 && this.collection[location] > this.collection[root])
		{
			this.swap(location, root);
			location = root;
			root = parseInt((location - 1) / this.k);
		}
	}
	// Handles the request of adding  new heap element
	addElement(data)
	{
		if (this.n + 1 >= this.limit)
		{
			process.stdout.write("\n Heap limit is exceeded When add new element");
			return;
		}
		this.collection[this.n] = data;
		this.n = this.n + 1;
		this.putElement(this.n - 1);
	}
	// After remove top of tree this are converted into a new max heap
	changeElement(location)
	{
		var update = -1;
		for (var i = 1; i <= this.k; ++i)
		{
			if ((location * this.k) + i < this.n 
                && this.collection[location] < this.collection[(location * this.k) + i])
			{
				if (update == -1)
				{
					// First largest child
					update = (location * this.k) + i;
				}
				else if (this.collection[update] < this.collection[(location * this.k) + i])
				{
					// When previous child is smaller
					update = (location * this.k) + i;
				}
			}
		}
		if (update >= 0)
		{
			// Swap element
			this.swap(location, update);
			// Check next updation
			this.changeElement(update);
		}
	}
	// Remove the max element from the tree
	extractMax()
	{
		if (this.n == 0)
		{
			process.stdout.write("\n Empty Heap ");
			return -1;
		}
		var element = this.collection[0];
		this.collection[0] = this.collection[this.n - 1];
		this.collection[this.n - 1] = 0;
		this.n = this.n - 1;
		this.changeElement(0);
		return element;
	}
	// Handles the request of displaying Tree elements
	printTree()
	{
		process.stdout.write("\n Level Order Heap Element \n");
		for (var i = 0; i < this.n; i++)
		{
			process.stdout.write("  " + this.collection[i]);
		}
		process.stdout.write("\n Preorder \n");
		this.preorder(0);
	}
}

function main()
{
	// Number of elements in heap
	// Set limit
	var limit = 50;
	// Possible child
	var k = 4;
	var heap = new KAryHeap(limit, k);
	// Add heap element
	heap.addElement(10);
	heap.addElement(7);
	heap.addElement(40);
	heap.addElement(2);
	heap.addElement(5);
	heap.addElement(15);
	heap.addElement(21);
	heap.addElement(35);
	heap.addElement(49);
	heap.addElement(38);
	heap.addElement(63);
	heap.addElement(19);
	/*Max heap of K 4
	        -----------------------   
	        
	                       63
	        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
	        │               │       │    │ 
	        40              49      2    5
	        |               │
	    ┌‒‒‒┬‒‒‒┬‒‒‒┐   ┌‒‒‒┬‒‒‒┐
	    │   │   │   │   │   │   │    
	    7  15   21  35  10  38  19
	    -------------------------------
	            Constructed Tree               
	        
	*/
	heap.printTree();
	process.stdout.write("\n Extract Max Element : " + heap.extractMax());
	/* Extract Max Element
	  -----------------------   
	    
	                       (49)
	        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
	        │               │       │    │ 
	      (40)             (38)     2    5
	        |               │
	    ┌‒‒‒┬‒‒‒┬‒‒‒┐     ┌‒‒‒┐
	    │   │   │   │     │   │      
	    7  15   21  35    10  19  
	    -------------------------------
	            After remove max node              
	        
	*/
	heap.printTree();
}
main();

Output

 Level Order Heap Element
  63  40  49  2  5  7  15  21  35  10  38  19
 Preorder
  63  40  7  15  21  35  49  10  38  19  2  5
 Extract Max Element : 63
 Level Order Heap Element
  49  40  38  2  5  7  15  21  35  10  19
 Preorder
  49  40  7  15  21  35  38  10  19  2  5
#  Python 3 program
#  K-ary Heap

class KAryHeap :

	
	def __init__(self, limit, k) :
		#  Set How many number of elements possible in heap
		self.limit = limit
		#  Set intial no element in heap
		self.n = 0
		#  Set number of child nodes
		self.k = k
		#  Allocate memory of heap elements
		self.collection = [0] * (limit)
	
	#  Display pre order view of ternary tree
	def preorder(self, root) :
		if (root < self.n) :
			print("  ", self.collection[root], end = "")
			i = 1
			#  Recursive visit to child node
			while (i <= self.k) :
				self.preorder(self.k * root + i)
				i += 1
			
		
	
	#  Swap two elements of heap collection
	def swap(self, first, second) :
		auxiliary = self.collection[first]
		self.collection[first] = self.collection[second]
		self.collection[second] = auxiliary
	
	#  This are converting tree into valid max heap when insert new element
	def putElement(self, location) :
		root = int((location - 1) / self.k)
		while (root >= 0 and self.collection[location] > self.collection[root]) :
			self.swap(location, root)
			location = root
			root = int((location - 1) / self.k)
		
	
	#  Handles the request of adding  new heap element
	def addElement(self, data) :
		if (self.n + 1 >= self.limit) :
			print("\n Heap limit is exceeded When add new element", end = "")
			return
		
		self.collection[self.n] = data
		self.n = self.n + 1
		self.putElement(self.n - 1)
	
	#  After remove top of tree this are converted into a new max heap
	def changeElement(self, location) :
		update = -1
		i = 1
		while (i <= self.k) :
			if ((location * self.k) + i < self.n 
                and self.collection[location] < self.collection[(location * self.k) + i]) :
				if (update == -1) :
					#  First largest child
					update = (location * self.k) + i
				
				elif(self.collection[update] < self.collection[(location * self.k) + i]) :
					#  When previous child is smaller
					update = (location * self.k) + i
				
			
			i += 1
		
		if (update >= 0) :
			#  Swap element
			self.swap(location, update)
			#  Check next updation
			self.changeElement(update)
		
	
	#  Remove the max element from the tree
	def extractMax(self) :
		if (self.n == 0) :
			print("\n Empty Heap ", end = "")
			return -1
		
		element = self.collection[0]
		self.collection[0] = self.collection[self.n - 1]
		self.collection[self.n - 1] = 0
		self.n = self.n - 1
		self.changeElement(0)
		return element
	
	#  Handles the request of displaying Tree elements
	def printTree(self) :
		print("\n Level Order Heap Element ")
		i = 0
		while (i < self.n) :
			print("  ", self.collection[i], end = "")
			i += 1
		
		print("\n Preorder ")
		self.preorder(0)
	

def main() :
	#  Number of elements in heap
	#  Set limit
	limit = 50
	#  Possible child
	k = 4
	heap = KAryHeap(limit, k)
	#  Add heap element
	heap.addElement(10)
	heap.addElement(7)
	heap.addElement(40)
	heap.addElement(2)
	heap.addElement(5)
	heap.addElement(15)
	heap.addElement(21)
	heap.addElement(35)
	heap.addElement(49)
	heap.addElement(38)
	heap.addElement(63)
	heap.addElement(19)
	# Max heap of K 4
	#         -----------------------   
	#         
	#                        63
	#         ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
	#         │               │       │    │ 
	#         40              49      2    5
	#         |               │
	#     ┌‒‒‒┬‒‒‒┬‒‒‒┐   ┌‒‒‒┬‒‒‒┐
	#     │   │   │   │   │   │   │    
	#     7  15   21  35  10  38  19
	#     -------------------------------
	#             Constructed Tree               
	#         
	
	heap.printTree()
	print("\n Extract Max Element : ", heap.extractMax(), end = "")
	#  Extract Max Element
	#   -----------------------   
	#     
	#                        (49)
	#         ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
	#         │               │       │    │ 
	#       (40)             (38)     2    5
	#         |               │
	#     ┌‒‒‒┬‒‒‒┬‒‒‒┐     ┌‒‒‒┐
	#     │   │   │   │     │   │      
	#     7  15   21  35    10  19  
	#     -------------------------------
	#             After remove max node              
	#         
	
	heap.printTree()

if __name__ == "__main__": main()

Output

 Level Order Heap Element
   63   40   49   2   5   7   15   21   35   10   38   19
 Preorder
   63   40   7   15   21   35   49   10   38   19   2   5
 Extract Max Element :  63
 Level Order Heap Element
   49   40   38   2   5   7   15   21   35   10   19
 Preorder
   49   40   7   15   21   35   38   10   19   2   5
#  Ruby program
#  K-ary Heap

class KAryHeap  
	# Define the accessor and reader of class KAryHeap  
	attr_reader :limit, :n, :k, :collection
	attr_accessor :limit, :n, :k, :collection
 
	
	#  Number of element
	
	#  Current element
	
	#  Number of child
	
	def initialize(limit, k) 
		#  Set How many number of elements possible in heap
		self.limit = limit
		#  Set intial no element in heap
		self.n = 0
		#  Set number of child nodes
		self.k = k
		#  Allocate memory of heap elements
		self.collection = Array.new(limit) {0}
	end

	#  Display pre order view of ternary tree
	def preorder(root) 
		if (root < self.n) 
			print("  ", self.collection[root])
			i = 1
			#  Recursive visit to child node
			while (i <= self.k) 
				self.preorder(self.k * root + i)
				i += 1
			end

		end

	end

	#  Swap two elements of heap collection
	def swap(first, second) 
		auxiliary = self.collection[first]
		self.collection[first] = self.collection[second]
		self.collection[second] = auxiliary
	end

	#  This are converting tree into valid max heap when insert new element
	def putElement(location) 
		root = (location - 1) / self.k
		while (root >= 0 && self.collection[location] > self.collection[root]) 
			self.swap(location, root)
			location = root
			root = (location - 1) / self.k
		end

	end

	#  Handles the request of adding  new heap element
	def addElement(data) 
		if (self.n + 1 >= self.limit) 
			print("\n Heap limit is exceeded When add new element")
			return
		end

		self.collection[self.n] = data
		self.n = self.n + 1
		self.putElement(self.n - 1)
	end

	#  After remove top of tree this are converted into a new max heap
	def changeElement(location) 
		update = -1
		i = 1
		while (i <= self.k) 
			if ((location * self.k) + i < self.n && self.collection[location] < self.collection[(location * self.k) + i]) 
				if (update == -1) 
					#  First largest child
					update = (location * self.k) + i
				elsif(self.collection[update] < self.collection[(location * self.k) + i]) 
					#  When previous child is smaller
					update = (location * self.k) + i
				end

			end

			i += 1
		end

		if (update >= 0) 
			#  Swap element
			self.swap(location, update)
			#  Check next updation
			self.changeElement(update)
		end

	end

	#  Remove the max element from the tree
	def extractMax() 
		if (self.n == 0) 
			print("\n Empty Heap ")
			return -1
		end

		element = self.collection[0]
		self.collection[0] = self.collection[self.n - 1]
		self.collection[self.n - 1] = 0
		self.n = self.n - 1
		self.changeElement(0)
		return element
	end

	#  Handles the request of displaying Tree elements
	def printTree() 
		print("\n Level Order Heap Element \n")
		i = 0
		while (i < self.n) 
			print("  ", self.collection[i])
			i += 1
		end

		print("\n Preorder \n")
		self.preorder(0)
	end

end

def main() 
	#  Number of elements in heap
	#  Set limit
	limit = 50
	#  Possible child
	k = 4
	heap = KAryHeap.new(limit, k)
	#  Add heap element
	heap.addElement(10)
	heap.addElement(7)
	heap.addElement(40)
	heap.addElement(2)
	heap.addElement(5)
	heap.addElement(15)
	heap.addElement(21)
	heap.addElement(35)
	heap.addElement(49)
	heap.addElement(38)
	heap.addElement(63)
	heap.addElement(19)
	# Max heap of K 4
	#         -----------------------   
	#         
	#                        63
	#         ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
	#         │               │       │    │ 
	#         40              49      2    5
	#         |               │
	#     ┌‒‒‒┬‒‒‒┬‒‒‒┐   ┌‒‒‒┬‒‒‒┐
	#     │   │   │   │   │   │   │    
	#     7  15   21  35  10  38  19
	#     -------------------------------
	#             Constructed Tree               
	#         
	
	heap.printTree()
	print("\n Extract Max Element : ", heap.extractMax())
	#  Extract Max Element
	#   -----------------------   
	#     
	#                        (49)
	#         ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
	#         │               │       │    │ 
	#       (40)             (38)     2    5
	#         |               │
	#     ┌‒‒‒┬‒‒‒┬‒‒‒┐     ┌‒‒‒┐
	#     │   │   │   │     │   │      
	#     7  15   21  35    10  19  
	#     -------------------------------
	#             After remove max node              
	#         
	
	heap.printTree()
end

main()

Output

 Level Order Heap Element 
  63  40  49  2  5  7  15  21  35  10  38  19
 Preorder 
  63  40  7  15  21  35  49  10  38  19  2  5
 Extract Max Element : 63
 Level Order Heap Element 
  49  40  38  2  5  7  15  21  35  10  19
 Preorder 
  49  40  7  15  21  35  38  10  19  2  5
/*
    Scala program
    K-ary Heap
*/
class KAryHeap(var limit: Int , var n: Int , var k: Int , var collection: Array[Int])
{
	def this(limit: Int, k: Int)
	{
		this(limit, 0, k, Array.fill[Int](limit)(0));
	}
	// Display pre order view of ternary tree
	def preorder(root: Int): Unit = {
		if (root < this.n)
		{
			print("  " + this.collection(root));
			var i: Int = 1;
			// Recursive visit to child node
			while (i <= this.k)
			{
				this.preorder(this.k * root + i);
				i += 1;
			}
		}
	}
	// Swap two elements of heap collection
	def swap(first: Int, second: Int): Unit = {
		var auxiliary: Int = this.collection(first);
		this.collection(first) = this.collection(second);
		this.collection(second) = auxiliary;
	}
	// This are converting tree into valid max heap when insert new element
	def putElement(position: Int): Unit = {
      	var location = position;
		var root: Int = ((location - 1) / this.k).toInt;
		while (root >= 0 && this.collection(location) > this.collection(root))
		{
			this.swap(location, root);
			location = root;
			root = ((location - 1) / this.k).toInt;
		}
	}
	// Handles the request of adding  new heap element
	def addElement(data: Int): Unit = {
		if (this.n + 1 >= this.limit)
		{
			print("\n Heap limit is exceeded When add new element");
			return;
		}
		this.collection(this.n) = data;
		this.n = this.n + 1;
		this.putElement(this.n - 1);
	}
	// After remove top of tree this are converted into a new max heap
	def changeElement(location: Int): Unit = {
		var update: Int = -1;
		var i: Int = 1;
		while (i <= this.k)
		{
			if ((location * this.k) + i < this.n && this.collection(location) < this.collection((location * this.k) + i))
			{
				if (update == -1)
				{
					// First largest child
					update = (location * this.k) + i;
				}
				else if (this.collection(update) < this.collection((location * this.k) + i))
				{
					// When previous child is smaller
					update = (location * this.k) + i;
				}
			}
			i += 1;
		}
		if (update >= 0)
		{
			// Swap element
			this.swap(location, update);
			// Check next updation
			this.changeElement(update);
		}
	}
	// Remove the max element from the tree
	def extractMax(): Int = {
		if (this.n == 0)
		{
			print("\n Empty Heap ");
			return -1;
		}
		var element: Int = this.collection(0);
		this.collection(0) = this.collection(this.n - 1);
		this.collection(this.n - 1) = 0;
		this.n = this.n - 1;
		this.changeElement(0);
		return element;
	}
	// Handles the request of displaying Tree elements
	def printTree(): Unit = {
		print("\n Level Order Heap Element \n");
		var i: Int = 0;
		while (i < this.n)
		{
			print("  " + this.collection(i));
			i += 1;
		}
		print("\n Preorder \n");
		this.preorder(0);
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		// Number of elements in heap
		// Set limit
		var limit: Int = 50;
		// Possible child
		var k: Int = 4;
		var heap: KAryHeap = new KAryHeap(limit, k);
		// Add heap element
		heap.addElement(10);
		heap.addElement(7);
		heap.addElement(40);
		heap.addElement(2);
		heap.addElement(5);
		heap.addElement(15);
		heap.addElement(21);
		heap.addElement(35);
		heap.addElement(49);
		heap.addElement(38);
		heap.addElement(63);
		heap.addElement(19);
		/*Max heap of K 4
		        -----------------------   
		        
		                       63
		        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
		        │               │       │    │ 
		        40              49      2    5
		        |               │
		    ┌‒‒‒┬‒‒‒┬‒‒‒┐   ┌‒‒‒┬‒‒‒┐
		    │   │   │   │   │   │   │    
		    7  15   21  35  10  38  19
		    -------------------------------
		            Constructed Tree               
		        
		*/
		heap.printTree();
		print("\n Extract Max Element : " + heap.extractMax());
		/* Extract Max Element
		  -----------------------   
		    
		                       (49)
		        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
		        │               │       │    │ 
		      (40)             (38)     2    5
		        |               │
		    ┌‒‒‒┬‒‒‒┬‒‒‒┐     ┌‒‒‒┐
		    │   │   │   │     │   │      
		    7  15   21  35    10  19  
		    -------------------------------
		            After remove max node              
		        
		*/
		heap.printTree();
	}
}

Output

 Level Order Heap Element
  63  40  49  2  5  7  15  21  35  10  38  19
 Preorder
  63  40  7  15  21  35  49  10  38  19  2  5
 Extract Max Element : 63
 Level Order Heap Element
  49  40  38  2  5  7  15  21  35  10  19
 Preorder
  49  40  7  15  21  35  38  10  19  2  5
/*
    Swift 4 program
    K-ary Heap
*/
class KAryHeap
{
	var limit: Int;
	// Number of element
	var n: Int;
	// Current element
	var k: Int;
	// Number of child
	var collection: [Int];
	init(_ limit: Int, _ k: Int)
	{
		// Set How many number of elements possible in heap
		self.limit = limit;
		// Set intial no element in heap
		self.n = 0;
		// Set number of child nodes
		self.k = k;
		// Allocate memory of heap elements
		self.collection = Array(repeating: 0, count: limit);
	}
	// Display pre order view of ternary tree
	func preorder(_ root: Int)
	{
		if (root < self.n)
		{
			print("  ", self.collection[root], terminator: "");
			var i: Int = 1;
			// Recursive visit to child node
			while (i <= self.k)
			{
				self.preorder(self.k * root + i);
				i += 1;
			}
		}
	}
	// Swap two elements of heap collection
	func swap(_ first: Int, _ second: Int)
	{
		let auxiliary: Int = self.collection[first];
		self.collection[first] = self.collection[second];
		self.collection[second] = auxiliary;
	}
	// This are converting tree into valid max heap when insert new element
	func putElement(_ position: Int)
	{	var location = position;
		var root: Int = (location - 1) / self.k;
		while (root >= 0 && self.collection[location] > self.collection[root])
		{
			self.swap(location, root);
			location = root;
			root = (location - 1) / self.k;
		}
	}
	// Handles the request of adding  new heap element
	func addElement(_ data: Int)
	{
		if (self.n + 1 >= self.limit)
		{
			print("\n Heap limit is exceeded When add new element", terminator: "");
			return;
		}
		self.collection[self.n] = data;
		self.n = self.n + 1;
		self.putElement(self.n - 1);
	}
	// After remove top of tree this are converted into a new max heap
	func changeElement(_ location: Int)
	{
		var update: Int = -1;
		var i: Int = 1;
		while (i <= self.k)
		{
			if ((location * self.k) + i < self.n 
                && self.collection[location] < self.collection[(location * self.k) + i])
			{
				if (update == -1)
				{
					// First largest child
					update = (location * self.k) + i;
				}
				else if (self.collection[update] < self.collection[(location * self.k) + i])
				{
					// When previous child is smaller
					update = (location * self.k) + i;
				}
			}
			i += 1;
		}
		if (update >= 0)
		{
			// Swap element
			self.swap(location, update);
			// Check next updation
			self.changeElement(update);
		}
	}
	// Remove the max element from the tree
	func extractMax()->Int
	{
		if (self.n == 0)
		{
			print("\n Empty Heap ", terminator: "");
			return -1;
		}
		let element: Int = self.collection[0];
		self.collection[0] = self.collection[self.n - 1];
		self.collection[self.n - 1] = 0;
		self.n = self.n - 1;
		self.changeElement(0);
		return element;
	}
	// Handles the request of displaying Tree elements
	func printTree()
	{
		print("\n Level Order Heap Element ");
		var i: Int = 0;
		while (i < self.n)
		{
			print("  ", self.collection[i], terminator: "");
			i += 1;
		}
		print("\n Preorder ");
		self.preorder(0);
	}
}
func main()
{
	// Number of elements in heap
	// Set limit
	let limit: Int = 50;
	// Possible child
	let k: Int = 4;
	let heap: KAryHeap = KAryHeap(limit, k);
	// Add heap element
	heap.addElement(10);
	heap.addElement(7);
	heap.addElement(40);
	heap.addElement(2);
	heap.addElement(5);
	heap.addElement(15);
	heap.addElement(21);
	heap.addElement(35);
	heap.addElement(49);
	heap.addElement(38);
	heap.addElement(63);
	heap.addElement(19);
	/*Max heap of K 4
	        -----------------------   
	        
	                       63
	        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
	        │               │       │    │ 
	        40              49      2    5
	        |               │
	    ┌‒‒‒┬‒‒‒┬‒‒‒┐   ┌‒‒‒┬‒‒‒┐
	    │   │   │   │   │   │   │    
	    7  15   21  35  10  38  19
	    -------------------------------
	            Constructed Tree               
	        
	*/
	heap.printTree();
	print("\n Extract Max Element : ", heap.extractMax(), terminator: "");
	/* Extract Max Element
	  -----------------------   
	    
	                       (49)
	        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
	        │               │       │    │ 
	      (40)             (38)     2    5
	        |               │
	    ┌‒‒‒┬‒‒‒┬‒‒‒┐     ┌‒‒‒┐
	    │   │   │   │     │   │      
	    7  15   21  35    10  19  
	    -------------------------------
	            After remove max node              
	        
	*/
	heap.printTree();
}
main();

Output

 Level Order Heap Element
   63   40   49   2   5   7   15   21   35   10   38   19
 Preorder
   63   40   7   15   21   35   49   10   38   19   2   5
 Extract Max Element :  63
 Level Order Heap Element
   49   40   38   2   5   7   15   21   35   10   19
 Preorder
   49   40   7   15   21   35   38   10   19   2   5
/*
    Kotlin program
    K-ary Heap
*/
class KAryHeap
{
	var limit: Int;
	var n: Int;
	var k: Int;
	var collection: Array <Int> ;
	constructor(limit: Int, k: Int)
	{
		// Set How many number of elements possible in heap
		this.limit = limit;
		// Set intial no element in heap
		this.n = 0;
		// Set number of child nodes
		this.k = k;
		// Allocate memory of heap elements
		this.collection = Array(limit)
		{
			0
		};
	}
	// Display pre order view of ternary tree
	fun preorder(root: Int): Unit
	{
		if (root < this.n)
		{
			print("  " + this.collection[root]);
			var i: Int = 1;
			// Recursive visit to child node
			while (i <= this.k)
			{
				this.preorder(this.k * root + i);
				i += 1;
			}
		}
	}
	// Swap two elements of heap collection
	fun swap(first: Int, second: Int): Unit
	{
		var auxiliary: Int = this.collection[first];
		this.collection[first] = this.collection[second];
		this.collection[second] = auxiliary;
	}
	// This are converting tree into valid max heap when insert new element
	fun putElement(position: Int): Unit
	{
      	var location = position;
		var root: Int = (location - 1) / this.k;
		while (root >= 0 && this.collection[location] > this.collection[root])
		{
			this.swap(location, root);
			location = root;
			root = (location - 1) / this.k;
		}
	}
	// Handles the request of adding  new heap element
	fun addElement(data: Int): Unit
	{
		if (this.n + 1 >= this.limit)
		{
			print("\n Heap limit is exceeded When add new element");
			return;
		}
		this.collection[this.n] = data;
		this.n = this.n + 1;
		this.putElement(this.n - 1);
	}
	// After remove top of tree this are converted into a new max heap
	fun changeElement(location: Int): Unit
	{
		var update: Int = -1;
		var i: Int = 1;
		while (i <= this.k)
		{
			if ((location * this.k) + i < this.n && this.collection[location] < this.collection[(location * this.k) + i])
			{
				if (update == -1)
				{
					// First largest child
					update = (location * this.k) + i;
				}
				else if (this.collection[update] < this.collection[(location * this.k) + i])
				{
					// When previous child is smaller
					update = (location * this.k) + i;
				}
			}
			i += 1;
		}
		if (update >= 0)
		{
			// Swap element
			this.swap(location, update);
			// Check next updation
			this.changeElement(update);
		}
	}
	// Remove the max element from the tree
	fun extractMax(): Int
	{
		if (this.n == 0)
		{
			print("\n Empty Heap ");
			return -1;
		}
		var element: Int = this.collection[0];
		this.collection[0] = this.collection[this.n - 1];
		this.collection[this.n - 1] = 0;
		this.n = this.n - 1;
		this.changeElement(0);
		return element;
	}
	// Handles the request of displaying Tree elements
	fun printTree(): Unit
	{
		print("\n Level Order Heap Element \n");
		var i: Int = 0;
		while (i < this.n)
		{
			print("  " + this.collection[i]);
			i += 1;
		}
		print("\n Preorder \n");
		this.preorder(0);
	}
}
fun main(args: Array < String > ): Unit
{
	// Number of elements in heap
	// Set limit
	var limit: Int = 50;
	// Possible child
	var k: Int = 4;
	var heap: KAryHeap = KAryHeap(limit, k);
	// Add heap element
	heap.addElement(10);
	heap.addElement(7);
	heap.addElement(40);
	heap.addElement(2);
	heap.addElement(5);
	heap.addElement(15);
	heap.addElement(21);
	heap.addElement(35);
	heap.addElement(49);
	heap.addElement(38);
	heap.addElement(63);
	heap.addElement(19);
	/*Max heap of K 4
	        -----------------------   
	        
	                       63
	        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
	        │               │       │    │ 
	        40              49      2    5
	        |               │
	    ┌‒‒‒┬‒‒‒┬‒‒‒┐   ┌‒‒‒┬‒‒‒┐
	    │   │   │   │   │   │   │    
	    7  15   21  35  10  38  19
	    -------------------------------
	            Constructed Tree               
	        
	*/
	heap.printTree();
	print("\n Extract Max Element : " + heap.extractMax());
	/* Extract Max Element
	  -----------------------   
	    
	                       (49)
	        ┌‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒┬‒‒‒‒‒‒‒┬‒‒‒‒┐
	        │               │       │    │ 
	      (40)             (38)     2    5
	        |               │
	    ┌‒‒‒┬‒‒‒┬‒‒‒┐     ┌‒‒‒┐
	    │   │   │   │     │   │      
	    7  15   21  35    10  19  
	    -------------------------------
	            After remove max node              
	        
	*/
	heap.printTree();
}

Output

 Level Order Heap Element
  63  40  49  2  5  7  15  21  35  10  38  19
 Preorder
  63  40  7  15  21  35  49  10  38  19  2  5
 Extract Max Element : 63
 Level Order Heap Element
  49  40  38  2  5  7  15  21  35  10  19
 Preorder
  49  40  7  15  21  35  38  10  19  2  5


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