Middle to top down level order traversal in binary tree

/*
    C Program 
    Middle to top down level order traversal in binary tree
*/
#include <stdio.h>
#include <stdlib.h>

// Tree Node
struct TreeNode
{
	int data;
	struct TreeNode *left;
	struct TreeNode *right;
};
// Binary Tree
struct BinaryTree
{
	struct TreeNode *root;
};
// Used to collect resultant node
struct LevelNode
{
	int element;
	struct LevelNode *next;
};
struct LevelRecord
{
	struct LevelNode *record;
};
// Create new tree
struct BinaryTree *newTree()
{
	// Create dynamic node
	struct BinaryTree *tree = (struct BinaryTree *) malloc(sizeof(struct BinaryTree));
	if (tree != NULL)
	{
		tree->root = NULL;
	}
	else
	{
		printf("Memory Overflow to Create tree Tree\n");
	}
	//return new tree
	return tree;
}
// returns a new node of tree
struct TreeNode *newNode(int data)
{
	// Create dynamic node
	struct TreeNode *node = (struct TreeNode *) malloc(sizeof(struct TreeNode));
	if (node != NULL)
	{
		//Set data and pointer values
		node->data = data;
		node->left = NULL;
		node->right = NULL;
	}
	else
	{
		//This is indicates, segmentation fault or memory overflow problem
		printf("Memory Overflow\n");
	}
	//return new node
	return node;
}
//Find height of given binary tree
int height(struct TreeNode *node)
{
	if (node != NULL)
	{
		int a = height(node->left);
		int b = height(node->right);
		if (a > b)
		{
			return a + 1;
		}
		else
		{
			return b + 1;
		}
	}
	else
	{
		return 0;
	}
}
// Add a node element in a given level
void addLevelElement(struct LevelRecord data[], int level, int element)
{
	struct LevelNode *node = (struct LevelNode *) malloc(sizeof(struct LevelNode));
	if (node != NULL)
	{
		// Add level node
		node->element = element;
		// connect new node to other elements
		node->next = data[level].record;
		// Add new node at beginning of level
		data[level].record = node;
	}
	else
	{
		printf("\n Memory Overflow When Create LevelNode\n");
	}
}
// Collect the elements of each level
void getLevelNodes(struct TreeNode *node, struct LevelRecord data[], int level)
{
	if (node != NULL)
	{
		// Add level node
		addLevelElement(data, level, node->data);
		// Visit right subtree
		getLevelNodes(node->right, data, level + 1);
		// Visit left subtree
		getLevelNodes(node->left, data, level + 1);
	}
}
// Print the elements of given level 
void printLevel(struct LevelNode *node)
{
	struct LevelNode *temp = node;
	struct LevelNode *auxiliary = NULL;
	// Print the level elements
	while (temp != NULL)
	{
		printf(" %d", temp->element);
		auxiliary = temp;
		// visit next node of level
		temp = auxiliary->next;
		// Remove current node of given level
		free(auxiliary);
		auxiliary = NULL;
	}
	printf("\n");
}
// Print the resulting level 
// Starting from middle 
// And up-down manner
void printLevelNodes(struct LevelRecord data[], int level)
{
	int middle = level / 2;
	for (int i = 0; i <= level / 2; ++i)
	{
		if (i == 0)
		{
			// Middle level
			printLevel(data[middle].record);
			data[middle].record = NULL;
		}
		else
		{
			if (middle - i >= 0)
			{
				// Middle top layer
				printLevel(data[middle - i].record);
				data[middle - i].record = NULL;
			}
			if (middle + i < level)
			{
				// Middle bottom layer
				printLevel(data[middle + i].record);
				data[middle + i].record = NULL;
			}
		}
	}
}
// Handles the request of printing resultant element in binary tree levels
void levelNodes(struct TreeNode *node)
{
	// Find the height
	int level = height(node);
	if (level != 0)
	{
		// This is used to store starting node of each level
		struct LevelRecord data[level];
		// Set initial value of each level
		for (int i = 0; i < level; ++i)
		{
			data[i].record = NULL;
		}
		// Get all level elements
		getLevelNodes(node, data, 0);
		// Print the level nodes
		printLevelNodes(data, level);
	}
	else
	{
		printf("\n Empty Tree \n");
	}
}
int main()
{
	// Define trees
	struct BinaryTree *tree = newTree();
	/*
	         1
	       /   \
	      2     3
	     / \   / \
	    3   4 6   5
	       /   \   \
	     -7     4   2
	     /     / \
	    9     1  -2  
	-----------------------
	    Binary Tree
	-----------------------
	*/
	tree->root = newNode(1);
	tree->root->left = newNode(2);
	tree->root->right = newNode(3);
	tree->root->left->left = newNode(3);
	tree->root->left->right = newNode(4);
	tree->root->left->right->left = newNode(-7);
	tree->root->left->right->left->left = newNode(9);
	tree->root->right->left = newNode(6);
	tree->root->right->right = newNode(5);
	tree->root->right->left->right = newNode(4);
	tree->root->right->right->right = newNode(2);
	tree->root->right->left->right->left = newNode(1);
	tree->root->right->left->right->right = newNode(-2);
	levelNodes(tree->root);
	return 0;
}

Output

 3 4 6 5
 2 3
 -7 4 2
 1
 9 1 -2