353637383940414243444546474849505152535455565758596061

# Class to represent a Binary Min Heap
class BinaryHeap:
    def __init__(self, capacity):
        self.capacity = capacity   # Maximum elements heap can store
        self.size = 0              # Current number of elements in heap
        self.arr = [0] * capacity  # Fixed-size list to store elements

    # Return parent index
    def parent(self, i):
        return (i - 1) // 2

    # Return left child index
    def left(self, i):
        return 2 * i + 1

    # Return right child index
    def right(self, i):
        return 2 * i + 2

    # Insert new element
    def insert(self, x):
        if self.size == self.capacity:
            print("Binary Heap Overflow!")
            return

        # Step 1: Place new element at end
        self.arr[self.size] = x
        k = self.size
        self.size += 1

        # Step 2: Bubble Up process to maintain Min-Heap property
        while k != 0 and self.arr[self.parent(k)] > self.arr[k]:
            self.arr[self.parent(k)], self.arr[k] = self.arr[k], self.arr[self.parent(k)]
            k = self.parent(k)

    # Return minimum element (root)
    def getMin(self):
        if self.size == 0:
            print("Heap is empty!")
            return float('inf')
        return self.arr[0]


# Driver code
if __name__ == "__main__":
    h = BinaryHeap(20)

    h.insert(4)
    h.insert(1)
    h.insert(2)
    h.insert(6)
    h.insert(7)
    h.insert(3)
    h.insert(8)
    h.insert(5)

    print("Min value is", h.getMin())

    h.insert(-1)
    print("Min value is", h.getMin())

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970

// Class to represent a Binary Min Heap
class BinaryHeap {
    constructor(capacity) {
        this.capacity = capacity;    // Maximum elements heap can store
        this.size = 0;               // Current number of elements
        this.arr = new Array(capacity); // Fixed-size array
    }

    // Parent index
    parent(i) {
        return Math.floor((i - 1) / 2);
    }

    // Left child index
    left(i) {
        return 2 * i + 1;
    }

    // Right child index
    right(i) {
        return 2 * i + 2;
    }

    // Insert new element
    insert(x) {
        if (this.size === this.capacity) {
            console.log("Binary Heap Overflow!");
            return;
        }

        // Step 1: Place element at end
        this.arr[this.size] = x;
        let k = this.size;
        this.size++;

        // Step 2: Bubble Up to rest