Binomial Heap Node deletion

// Include header file
#include <stdio.h>
#include <stdlib.h>

/*
    C program 
    Binomial Heap Node deletion
*/
// Define TreeNode
struct TreeNode
{
    int key;
    int counter;
    struct TreeNode *sibling;
    struct TreeNode *parent;
    struct TreeNode *child;
};
// Define BinomialHeap
struct BinomialHeap
{
    struct TreeNode *root;
};
// Returns a new node of tree
struct TreeNode *newNode(int key, struct TreeNode *sibling)
{
    struct TreeNode *node = (struct TreeNode *) malloc(sizeof(struct TreeNode));
    if (node != NULL)
    {
        node->key = key;
        node->sibling = sibling;
        // Set default value of node
        node->child = NULL;
        node->parent = NULL;
        node->counter = 0;
    }
    else
    {
        printf("\n Memory Overflow to create tree node\n");
    }
    return node;
}
// This is provide new Binomial Heap Tree
struct BinomialHeap *newTree()
{
    struct BinomialHeap *tree = (struct BinomialHeap *) malloc(sizeof(struct BinomialHeap));
    if (tree != NULL)
    {
        tree->root = NULL;
    }
    else
    {
        printf("\n Memory Overflow to create new tree \n");
    }
    return tree;
}
// Determine that whether the given node and next sibling tree have same number of children nodes
int isCombine(struct TreeNode *node)
{
    if (node != NULL && node->sibling != NULL && node->counter == node->sibling->counter)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
// This is attack child tree into parent tree
struct TreeNode *changeRelation(struct TreeNode *parentNode, struct TreeNode *childNode)
{
    if (parentNode->sibling == childNode)
    {
        parentNode->sibling = childNode->sibling;
    }
    childNode->sibling = parentNode->child;
    parentNode->child = childNode;
    childNode->parent = parentNode;
    parentNode->counter += 1;
    return parentNode;
}
// Recursively merging of two tree
struct TreeNode *merge(struct TreeNode *node1, struct TreeNode *node2)
{
    struct TreeNode *temp = NULL;
    if (node1->key < node2->key)
    {
        temp = changeRelation(node1, node2);
    }
    else
    {
        temp = changeRelation(node2, node1);
    }
    if (isCombine(temp) == 1)
    {
        temp = merge(temp, temp->sibling);
    }
    return temp;
}
// Handles the request of add new key into the tree
void insert(struct BinomialHeap *tree, int key)
{
    // Create new node of tree
    struct TreeNode *node = newNode(key, tree->root);
    if (tree->root == NULL)
    {
        // When add subtree node
        tree->root = node;
    }
    else if (isCombine(node) == 1)
    {
        // When need to combine two sibling 
        tree->root = merge(node, tree->root);
    }
    else
    {
        tree->root = node;
    }
}
// This is sort add subtree
struct TreeNode *addSubTree(struct TreeNode *front, struct TreeNode *subtree)
{
    if (front == NULL)
    {
        return subtree;
    }
    else if (subtree->counter > front->counter)
    {
        front->sibling = addSubTree(front->sibling, subtree);
    }
    else
    {
        // Add subtree before front tree
        subtree->sibling = front;
        if (isCombine(subtree) == 1)
        {
            // Returns the  new result after added subtree
            return merge(subtree, front);
        }
        else
        {
            // Add subtree are valid
            return subtree;
        }
    }
}
// In-order view of Binomial Heap from left to right in top tree
void printTree(struct TreeNode *node)
{
    if (node == NULL)
    {
        return;
    }
    printf("  %d", node->key);
    // Visit of child and sibling nodes
    printTree(node->child);
    printTree(node->sibling);
}
// Return minimum key value of tree
int minimum(struct TreeNode *root)
{
    if (root == NULL)
    {
        // When empty tree
        return -1;
    }
    struct TreeNode *auxiliary = root;
    int result = root->key;
    // Find last node
    while (auxiliary!= NULL)
    {
        if (result > auxiliary->key)
        {
            result = auxiliary->key;
        }
        auxiliary = auxiliary->sibling;
    }
    return result;
}
// This is handles request to delete minimum nodes of Binomial heap
void deleteMinKey(struct BinomialHeap *tree)
{
    if (tree->root == NULL)
    {
        printf("\n Empty Tree \n");
        return;
    }
    // Define some useful variables
    struct TreeNode *node = NULL;
    struct TreeNode *auxiliary = NULL;
    struct TreeNode *small = tree->root;
    // Starting to first tree
    node = tree->root;
    // Find min key subtree in top of Binomial heap
    while (node->sibling != NULL)
    {
        if (node->sibling->key < small->key)
        {
            auxiliary = node;
            small = node->sibling;
        }
        // Visits to next sibling
        node = node->sibling;
    }
    if (auxiliary != NULL)
    {
        // Segregate the minimum key subtree
        auxiliary->sibling = small->sibling;
    }
    else
    {
        // Delete first subtree
        tree->root = small->sibling;
    }
    // Get the child of deleted min key node
    node = small->child;
    // Add the delete node child into actual tree
    while (node != NULL)
    {
        auxiliary = node;
        node = node->sibling;
        //Set default value of subtree
        auxiliary->sibling = NULL;
        auxiliary->parent = NULL;
        // Add subtree to actual tree
        tree->root = addSubTree(tree->root, auxiliary);
    }
    printf("\n After Delete small Node : %d \n", small->key);
    // Delete minimum value key node
    free(small);
    small = NULL;
    printTree(tree->root);
}
int main()
{
    struct BinomialHeap *tree = newTree();
    // Add tree element
    insert(tree, 6);
    insert(tree, 5);
    insert(tree, 9);
    insert(tree, 3);
    insert(tree, 4);
    insert(tree, 11);
    insert(tree, 1);
    insert(tree, 7);
    insert(tree, 12);
    insert(tree, 10);
    insert(tree, 21);
    printf("\n Constructing Binomial Heap \n");
    /*
    Constructing of Binomial Heap
    ==========================
    21-------10 ----------- 1
             |            / | \   
             |           /  |  \
             12         3   4   7
                       / \  |
                      /   \ |
                      5   9 11
                      |
                      |
                      6
    ==========================
    Logical view    
    */
    printTree(tree->root);
    printf("\n Minimum node : %d ", minimum(tree->root));
    deleteMinKey(tree);
    /* 
    After Detete Min Node 1
    ==========================

     7 ------------  3
     |            /  |  \   
     |           /   |   \
     21         4    5    9
               / \   |
              /   \  |
             10   11 6
             |
             |
             12
    ==========================
    Logical view    
    */
    deleteMinKey(tree);
    /* 
    After Detete Min Node 3
    ==========================

     9 ------------  4
                  /  |  \   
                 /   |   \
                5   10   11
               / \   |
              /   \  |
             7     6 12
             |
             |
             21
    ==========================
    Logical view    
    */
    deleteMinKey(tree);
    /* 
    After Detete Min Node 4
    ==========================

               5
             / | \   
            /  |  \
           9   7   6
         / |   |
       10  11  |
       |       21
       12


    ==========================
    Logical view    
    */
    deleteMinKey(tree);
    /* 
    After Detete Min Node 5
    =========================

    6 -------7 ----------- 9
             |           / |    
             |          /  |  
             21        10  11   
                       |
                       |
                       12              
    Logical view    
    */
    return 0;
}

Output

 Constructing Binomial Heap
  21  10  12  1  3  5  6  9  4  11  7
 Minimum node : 1
 After Delete small Node : 1
  7  21  3  4  10  12  11  5  6  9
 After Delete small Node : 3
  9  4  5  7  21  6  10  12  11
 After Delete small Node : 4
  5  9  10  12  11  7  21  6
 After Delete small Node : 5
  6  7  21  9  10  12  11