B Tree node insertion

// C Program 
// B-Tree node insertion
#include <stdio.h>
#include <stdlib.h>

// Define tree node
struct TreeNode
{
	int *keys;
	struct TreeNode **child;
	int count;
	int leaf;
	int degree;
};
// Define structure of B Tree
struct BTree
{
	int degree;
	struct TreeNode *root;
};
// Returns the new b tree
struct BTree *createTree(int degree)
{
	struct BTree *tree = (struct BTree *) malloc(sizeof(struct BTree));
	if (tree != NULL)
	{
		tree->degree = degree;
		tree->root = NULL;
	}
	else
	{
		printf("\n Memory Overflow when create new Tree");
	}
}
// Creating and returning new node of b tree
struct TreeNode *createNode(int degree, int leaf)
{
	struct TreeNode *node = (struct TreeNode *) malloc(sizeof(struct TreeNode));
	if (node != NULL)
	{
		// Create memory of node key
		node->keys = (int *) malloc((sizeof(int)) *(2 *degree - 1));
		// Allocate memory of node child
		node->child = (struct TreeNode **) malloc((2 *degree) *sizeof(struct TreeNode *));
		// Set initial child
		for (int i = 0; i < degree *2 - 1; ++i)
		{
			node->child[i] = NULL;
		}
		node->leaf = leaf;
		node->degree = degree;
		node->count = 0;
	}
}
// This function are split the child node
void splitChildNodes(struct TreeNode *x, struct TreeNode *y, int i)
{
	// Create new node z
	struct TreeNode *z = createNode(y->degree, y->leaf);
	z->count = x->degree - 1;
	int j = 0;
	// Get key
	for (j = 0; j < x->degree - 1; j++)
	{
		z->keys[j] = y->keys[j + x->degree];
		//reset slot value
		y->keys[j + x->degree] = 0;
	}
	if (y->leaf == 0)
	{
		// Get child value
		for (j = 0; j < x->degree; j++)
		{
			z->child[j] = y->child[j + x->degree];
			y->child[j + x->degree] = NULL;
		}
	}
	y->count = x->degree - 1;
	for (j = x->count; j >= i + 1; j--)
	{
		x->child[j + 1] = x->child[j];
	}
	x->child[i + 1] = z;
	for (j = x->count - 1; j >= i; j--)
	{
		x->keys[j + 1] = x->keys[j];
	}
	x->keys[i] = y->keys[x->degree - 1];
	y->keys[x->degree - 1] = 0;
	x->count = x->count + 1;
}
// Set key into the node
void setValue(struct TreeNode *node, int key)
{
	int i = node->count - 1;
	if (node->leaf == 1)
	{
		// When get leaf node
		// Find location to add new key
		while (i >= 0 && node->keys[i] > key)
		{
			node->keys[i + 1] = node->keys[i];
			i--;
		}
		// Add new key
		node->keys[i + 1] = key;
		// Update node key counter
		node->count = node->count + 1;
	}
	else
	{
		while (i >= 0 && node->keys[i] > key)
		{
			i--;
		}
		if (node->child[i + 1]->count == 2 *node->degree - 1)
		{
			// When need to split child nodes
			splitChildNodes(node, node->child[i + 1], i + 1);
			if (node->keys[i + 1] < key)
			{
				i++;
			}
		}
		setValue(node->child[i + 1], key);
	}
}
// Handles the request to add new node in B Tree
void insert(struct BTree *tree, int key)
{
	if (tree->root == NULL)
	{
		// When add first node of tree
		tree->root = createNode(tree->degree, 1);
		// set key value
		tree->root->keys[0] = key;
		tree->root->count++;
	}
	else
	{
		if (tree->root->count == 2 *tree->degree - 1)
		{
			struct TreeNode *node = createNode(tree->degree, 0);
			node->child[0] = tree->root;
			splitChildNodes(node, tree->root, 0);
			int i = 0;
			if (node->keys[0] < key)
			{
				i++;
			}
			setValue(node->child[i], key);
			// set new root
			tree->root = node;
		}
		else
		{
			setValue(tree->root, key);
		}
	}
}
// Display tree elements
void traversal(struct TreeNode *node)
{
	if (node != NULL)
	{
		int i = 0;
		while (i < node->count)
		{
			traversal(node->child[i]);
			printf("%d  ", node->keys[i]);
			i++;
		}
		traversal(node->child[i]);
	}
}
// Find that given element exists in b tree
int search(struct TreeNode *node, int key)
{
	if (node != NULL)
	{
		int i = 0;
		while (i < node->count)
		{
			if (search(node->child[i], key) == 1 || node->keys[i] == key)
			{
				return 1;
			}
			i++;
		}
		return search(node->child[i], key);
	}
	else
	{
		return 0;
	}
}
int main(int argc, char
	const *argv[])
{
	// Create b-tree with degree 3
	struct BTree *tree = createTree(3);
	insert(tree, 13);
	insert(tree, 5);
	insert(tree, 3);
	insert(tree, 6);
	insert(tree, 37);
	insert(tree, 23);
	insert(tree, 8);
	insert(tree, 9);
	insert(tree, 10);
	insert(tree, 26);
	insert(tree, 12);
	insert(tree, 7);
	insert(tree, 11);
	/*
	      (6,  9, 13)
	      /   |  \   \
	     /    |   \   (23,26,37)   
	  (3,5) (7,8) (10,11,12)

	  Constructed B Tree
	*/
	traversal(tree->root);
	return 0;
}

Output

3  5  6  7  8  9  10  11  12  13  23  26  37