C++ Program to Implement Binomial Heap

// C++ Program to Implement Binomial Heap

#include <iostream>
#include <limits>
#include <vector>
using namespace std;

// Structure for Binomial Node
template <typename T> struct BinomialNode {
    T key;
    int degree;
    BinomialNode<T>* parent;
    BinomialNode<T>* child;
    BinomialNode<T>* sibling;

    // Constructor to initialize a Binomial Node
    BinomialNode(T k)
        : key(k)
        , degree(0)
        , parent(nullptr)
        , child(nullptr)
        , sibling(nullptr)
    {
    }
};

// Class for Binomial Heap
template <typename T> class BinomialHeap {
private:
    BinomialNode<T>*
        head; // Pointer to the head of the binomial heap

    // Function to merge two binomial trees of the same
    // degree
    BinomialNode<T>* mergeTrees(BinomialNode<T>* b1,
                                BinomialNode<T>* b2)
    {
        // Ensure b1 has the smaller key
        if (b1->key > b2->key)
            swap(b1, b2);
        // Make b1 the parent of b2
        b2->parent = b1;
        // Link b2 as the first child of b1
        b2->sibling = b1->child;
        // Update b1's child to b2
        b1->child = b2;
        // Increase the degree of b1
        b1->degree++;
        return b1;
    }

    // Function to consolidate the heap to ensure no two
    // binomial trees have the same degree
    void consolidate()
    {
        // Create a vector to store trees by degree
        vector<BinomialNode<T>*> trees(64, nullptr);
        BinomialNode<T>* current = head;
        head = nullptr;

        while (current != nullptr) {
            // Get the next node
            BinomialNode<T>* next = current->sibling;
            // Disconnect the current node from its sibling
            current->sibling = nullptr;
            int degree = current->degree;
            while (trees[degree] != nullptr) {
                // Merge trees of the same degree
                current
                    = mergeTrees(current, trees[degree]);
                trees[degree] = nullptr;
                degree++;
            }
            trees[degree] = current;
            current = next;
        }

        for (BinomialNode<T>* tree : trees) {
            if (tree != nullptr) {
                tree->sibling = head;
                head = tree;
            }
        }
    }

public:
    BinomialHeap()
        : head(nullptr)
    {
    }

    // Function to insert a key into the heap
    void insert(T key)
    {
        BinomialHeap newHeap;
        // Create a new heap with a single node
        newHeap.head = new BinomialNode<T>(key);
        // Merge the new heap into the current heap
        merge(newHeap);
    }

    // Function to Merge another binomial heap into the
    // current heap
    void merge(BinomialHeap& other)
    {
        BinomialNode<T>* newHead = nullptr;
        BinomialNode<T>** curr = &newHead;
        BinomialNode<T>* h1 = head;
        BinomialNode<T>* h2 = other.head;

        // Merge the root lists of both heaps
        while (h1 != nullptr && h2 != nullptr) {
            if (h1->degree <= h2->degree) {
                *curr = h1;
                h1 = h1->sibling;
            }
            else {
                *curr = h2;
                h2 = h2->sibling;
            }
            curr = &((*curr)->sibling);
        }

        if (h1 != nullptr)
            *curr = h1;
        if (h2 != nullptr)
            *curr = h2;

        head = newHead;
        // Consolidate the heap to ensure no two trees have
        // the same degree
        consolidate();
        // Clear the other heap
        other.head = nullptr;
    }

    // Function to extract the minimum key from the heap
    T extractMin()
    {
        if (head == nullptr)
            throw runtime_error("Heap is empty");

        BinomialNode<T>* minNode = head;
        BinomialNode<T>* prevMin = nullptr;
        BinomialNode<T>* current = head->sibling;
        BinomialNode<T>* prev = head;

        // Find the minimum key in the root list
        while (current != nullptr) {
            if (current->key < minNode->key) {
                minNode = current;
                prevMin = prev;
            }
            prev = current;
            current = current->sibling;
        }

        // Remove the minimum node from the root list
        if (prevMin == nullptr)
            head = head->sibling;
        else
            prevMin->sibling = minNode->sibling;

        BinomialHeap newHeap;
        BinomialNode<T>* child = minNode->child;
        while (child != nullptr) {
            BinomialNode<T>* next = child->sibling;
            child->parent = nullptr;
            child->sibling = newHeap.head;
            newHeap.head = child;
            child = next;
        }

        T minKey = minNode->key;
        // Delete the minimum node
        delete minNode;
        // Merge the children of the minimum node back into
        // the heap
        merge(newHeap);
        return minKey;
    }

    // Function to Decreases the key of a given node
    void decreaseKey(BinomialNode<T>* node, T newKey)
    {
        if (newKey > node->key)
            throw runtime_error(
                "New key is greater than current key");

        node->key = newKey;
        BinomialNode<T>* current = node;
        BinomialNode<T>* parent = current->parent;

        // Bubble up the new key if necessary
        while (parent != nullptr
               && current->key < parent->key) {
            swap(current->key, parent->key);
            current = parent;
            parent = current->parent;
        }
    }

    // Function to delete a given node from the heap
    void deleteNode(BinomialNode<T>* node)
    {
        decreaseKey(node, numeric_limits<T>::min());
        extractMin();
    }

    // Function to print the binomial heap
    void printHeap()
    {
        BinomialNode<T>* current = head;
        while (current != nullptr) {
            cout << "B" << current->degree << " ";
            printTree(current);
            cout << endl;
            current = current->sibling;
        }
    }

private:
    // Recursively prints a binomial tree
    void printTree(BinomialNode<T>* root)
    {
        cout << root->key << " ";
        BinomialNode<T>* child = root->child;
        while (child != nullptr) {
            printTree(child);
            child = child->sibling;
        }
    }
};

int main()
{
    BinomialHeap<int> heap;

    // Insert elements
    heap.insert(10);
    heap.insert(20);
    heap.insert(5);
    heap.insert(15);
    heap.insert(25);

    cout << "Binomial Heap after insertions:" << endl;
    heap.printHeap();

    // Extract minimum
    int min = heap.extractMin();
    cout << "\nExtracted minimum: " << min << endl;
    cout << "Binomial Heap after extracting minimum:"
         << endl;
    heap.printHeap();

    // Merge with another heap
    BinomialHeap<int> otherHeap;
    otherHeap.insert(7);
    otherHeap.insert(12);

    heap.merge(otherHeap);
    cout << "\nBinomial Heap after merging:" << endl;
    heap.printHeap();

    return 0;
}