Skip to content
Related Articles

Related Articles

Java Program to Implement Leftist Heap

Improve Article
Save Article
  • Difficulty Level : Expert
  • Last Updated : 06 Apr, 2022
Improve Article
Save Article

A leftist heap is a priority Queue implemented with a binary heap. Every node has a sValue which is at the nearest Distance to the other nodes. Now we will write a java program for performing certain operations on a leftist Heap (Inorder Traversal) like insert, delete, clear, and check for empty.

A leftist tree is a binary tree with properties:

  1. Normal Min Heap Property : key(i) >= key(parent(i))
  2. Heavier on left side : dist(right(i)) <= dist(left(i)). Here, dist(i) is the number of edges on the shortest path from node i to a leaf node in extended binary tree representation (In this representation, a null child is considered as an external or leaf node). The shortest path to a descendant external node is through the right child. Every subtree is also a leftist tree and dist( i ) = 1 + dist( right( i ) ).

Example: The below leftist tree is presented with its distance calculated for each node with the procedure mentioned above. The rightmost node has a rank of 0 as the right subtree of this node is null and its parent has a distance of 1 by dist( i ) = 1 + dist( right( i )). The same is followed for each node and their s-value( or rank) is calculated.


From the above second property, we can draw two conclusions :

  1. The path from the root to the rightmost leaf is the shortest path from the root to the leaf.
  2. If the path to the rightmost leaf has x nodes, then the leftist heap has at least 2x – 1 node. This means the length of the path to the rightmost leaf is O(log n) for a leftist heap with n nodes.


Functions to do
2. delete min
3. check empty
4. clear
Inorder Traversal: 53 52 54  
If you wish to continue type Y or y
Functions to do
2. delete min
3. check empty
4. clear
Empty status = false
Inorder Traversal: 53 52 54  
If you wish to continue type Y or y
Functions to do
2. delete min
3. check empty
4. clear
Inorder Traversal:  
If you wish to continue type Y or y


  • We will first take a class Node and create its constructor and various parameters.
  • Then we will create a class LeftHeap, In this class, we will create various methods and try to perform their operations.
  • We will create a constructor, where we keep the root null.
  • We will create a method isEmpty() to check if the Heap is empty.
  • We will create a method clear(), to clear the heap.
  • We create a method to merge:
    • Here we need to take two nodes, and then we would check for both of them being empty
    • Then we would set the values right or left according to our convenience.
    • This function is used to find the minimum element in the heap
  • Then we declare a function named del().
    • This function is used to find the minimum number, and then we remove it.
  • Then we declare the main function and call the function and do operations performed with the help of a switch case. The operations performed are whether to check if it is empty or to empty the heap or delete the minimum element.



// Java Program to Implement Leftist Heap
// Declare all libraries
import java.util.Scanner;
// Class Node
class Node {
    // elements, and sValue are the variables in class Node
    int element, sValue;
    // class has two parameters
    Node left, right;
    public Node(int element) { this(element, null, null); }
    // Function Node where we are using this keyword
    // Which will help us to avoid confusion if we are having
    // same elements
    public Node(int element, Node left, Node right)
        this.element = element;
        this.left = left;
        this.right = right;
        this.sValue = 0;
// Class Left heap
class LeftHeap {
    // Now parameter is created named head.
    private Node head;
    // Its constructor is created named left heap
    // Returns null
    public LeftHeap() { head = null; }
    // Now we will write function to check if the list is
    // empty
    public boolean isEmpty()
        // If head is null returns true
        return head == null;
    // Now we will write a function clear
    public void clear()
        // We will put head is null
        head = null;
    // Now let us create a function merge which will
    // help us merge
    public void merge(LeftHeap rhs)
        // If the present function is rhs
        // then we return it
        if (this == rhs)
        // Here we call the function merge
        // And make rhs is equal to null
        head = merge(head, rhs.head);
        rhs.head = null;
    // Function merge with two Nodes a and b
    public Node merge(Node a, Node b)
        // If A is null
        // We return b
        if (a == null)
            return b;
        // If b is null
        // we return A
        if (b == null)
            return a;
        // If we put a element greater than b element
        if (a.element > b.element) {
            // We write the swap code
            Node temp = a;
            a = b;
            b = temp;
        // Now we call the function merge to merge a and b
        a.right = merge(a.right, b);
        // If a is null we swap right with left and empty
        // right
        if (a.left == null) {
            a.left = a.right;
            a.right = null;
        // else
        // if value in a is less than the svalue of right
        // If the condition is satisfied , we swap the left
        // with right
        else {
            if (a.left.sValue < a.right.sValue) {
                Node temp = a.left;
                a.left = a.right;
                a.right = temp;
            // we store the value in a s Value of right
            // SValue
            a.sValue = a.right.sValue + 1;
        // We now return the value of a
        return a;
    // Function insert
    public void insert(int a)
        // This root will help us insert a new variable
        head = merge(new Node(a), head);
    // The below function will help us delete minimum
    // function present in the Heap
    public int del()
        // If is empty return -1
        if (isEmpty())
            return -1;
        // Now we will store the element in variable and
        // Call the merge function to del that is converging
        // to head then  we return min
        int min = head.element;
        head = merge(head.left, head.right);
        return min;
    // Function order
    // will print the starting and ending points in order.
    public void order()
    // Function order with Node r
    // If r not equal to r
    // It prints all the elements iterating from order left
    // to right
    private void order(Node r)
        if (r != null) {
            System.out.print(r.element + " ");
// Class gfg
class GFG {
    public static void main(String[] args)
        // Creating the scanner object
        Scanner sc = new Scanner(;
        System.out.println("LEFTIST HEAP");
        // Creating object for class LeftHeap
        LeftHeap h = new LeftHeap();
        // Char ch
        char ch;
        // Now taking the loop
        do {
            // Now writing down all the functions
            System.out.println("Functions to do");
            System.out.println("1. insert");
            System.out.println("2. delete min");
            System.out.println("3. check empty");
            System.out.println("4. clear");
            // Scanning the choice to be used in switch
            int choice = sc.nextInt();
            // Using switch
            switch (choice) {
                // Case 1
                // to insert the elements in the heap
                // call the insert func
            case 1:
                System.out.println("Enter integer element to insert");
                // Delete the minimum element in the func
            case 2:
                // To check the empty status of the heap
            case 3:
                System.out.println("Empty status = "
                                   + h.isEmpty());
                // Cleaning the heap
            case 4:
                System.out.println("Wrong entry");
            // Prints the inorder traversal
            // Calling the func
            System.out.print("\n Inorder Traversal: ");
            // Whether to continue or not
            System.out.println("\n If you wish to continue type Y or y");
            ch =;
        // Closing of loop
        while (ch == 'Y' || ch == 'y');



My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!