Leftist Heap - Problem

A leftist heap is a priority queue implemented as a binary tree where the heap property is maintained and the tree is leftist - meaning for every node, the rank of the left child is greater than or equal to the rank of the right child.

The rank of a node is defined as the length of the shortest path from that node to any external node (null). An external node has rank 0.

Implement a LeftistHeap class that supports:

insert(value) - Insert a value into the heap
deleteMin() - Remove and return the minimum value
merge(other) - Merge with another leftist heap
isEmpty() - Check if heap is empty
getMin() - Get minimum value without removing it

All operations should run in O(log n) time complexity using rank-based merging.

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["insert", 3], ["insert", 7], ["getMin"], ["deleteMin"], ["isEmpty"]]

› Output: [3, 3, false]

💡 Note: Insert 3 and 7, getMin returns 3, deleteMin removes and returns 3, isEmpty returns false since 7 remains

Example 2 — Multiple Inserts and Deletes

$ Input: operations = [["insert", 5], ["insert", 2], ["insert", 8], ["deleteMin"], ["deleteMin"], ["getMin"]]

› Output: [2, 5, 8]

💡 Note: Insert 5, 2, 8. DeleteMin twice returns 2 then 5. GetMin shows remaining minimum is 8

Example 3 — Empty Heap Operations

$ Input: operations = [["isEmpty"], ["insert", 10], ["deleteMin"], ["isEmpty"]]

› Output: [true, 10, true]

💡 Note: Initially empty (true), insert 10, deleteMin returns 10, now empty again (true)

Constraints

1 ≤ operations.length ≤ 1000
-10⁴ ≤ value ≤ 10⁴
All operations are valid (no deleteMin on empty heap)

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 F Facebook 15 a Amazon 12

The leftist heap uses the key insight that maintaining a leftist property (left child rank ≥ right child rank) enables efficient O(log n) merging. The optimal approach implements rank-based merging where all operations follow the right spine path. Time: O(log n), Space: O(n)

Common Approaches

✓ Brute Force Array Implementation

⏱️ Time: O(n) Space: O(n)

Store all elements in an unsorted array. For each delete-min operation, scan the entire array to find minimum. For merge, concatenate arrays.

Leftist Heap with Rank-Based Merging

⏱️ Time: O(log n) Space: O(n)

Implement leftist heap as binary tree where rank of left child ≥ rank of right child. Rank is shortest path to external node. Merge by recursively comparing roots and maintaining leftist property.

Standard Binary Heap

⏱️ Time: O(n log n) Space: O(n)

Implement using complete binary tree stored in array. Maintain heap property with heapify operations, but merge requires extracting all elements from one heap and inserting into another.

Brute Force Array Implementation — Algorithm Steps

Store elements in unsorted array
For deleteMin: scan entire array to find minimum
For insert: append to end
For merge: concatenate arrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Insert

Append new elements to end of array

Find Min

Scan entire array to find minimum value

Delete Min

Remove minimum and shift remaining elements

Code -

solution.c — C

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

#define MAX_SIZE 1000

typedef struct {
    int data[MAX_SIZE];
    int size;
} LeftistHeap;

void init_heap(LeftistHeap* heap) {
    heap->size = 0;
}

void insert(LeftistHeap* heap, int value) {
    if (heap->size < MAX_SIZE) {
        heap->data[heap->size++] = value;
    }
}

int deleteMin(LeftistHeap* heap) {
    if (heap->size == 0) return -1;
    
    int minIdx = 0;
    for (int i = 1; i < heap->size; i++) {
        if (heap->data[i] < heap->data[minIdx]) {
            minIdx = i;
        }
    }
    
    int minVal = heap->data[minIdx];
    for (int i = minIdx; i < heap->size - 1; i++) {
        heap->data[i] = heap->data[i + 1];
    }
    heap->size--;
    return minVal;
}

int getMin(LeftistHeap* heap) {
    if (heap->size == 0) return -1;
    
    int minVal = heap->data[0];
    for (int i = 1; i < heap->size; i++) {
        if (heap->data[i] < minVal) {
            minVal = heap->data[i];
        }
    }
    return minVal;
}

int isEmpty(LeftistHeap* heap) {
    return heap->size == 0;
}

void merge_heaps(LeftistHeap* heap1, LeftistHeap* heap2) {
    for (int i = 0; i < heap2->size && heap1->size < MAX_SIZE; i++) {
        heap1->data[heap1->size++] = heap2->data[i];
    }
    heap2->size = 0;
}

int main() {
    printf("[]");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

DeleteMin and getMin require scanning entire array

⚡ Linearithmic

Space Complexity

O(n)

Array stores all n elements

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~35 min Avg. Time

856 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Leftist Heap - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Array Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler