Construct a mirror tree from the given binary tree

/*
    C Program 
    Construct a mirror tree from the given 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;
};
// 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;
}
struct TreeNode *createMirror(struct TreeNode *node)
{
	if (node == NULL)
	{
		return NULL;
	}
	// Create a new node
	struct TreeNode *n = newNode(node->data);
	// Get the left node of created node
	n->left = createMirror(node->right);
	// Get the right node of created node
	n->right = createMirror(node->left);
	// Returns the constructed node
	return n;
}
// Print tree elements
void preorder(struct TreeNode *node)
{
	if (node != NULL)
	{
		//Print node value
		printf("  %d", node->data);
		preorder(node->left);
		preorder(node->right);
	}
}
int main()
{
	// Define tree
	struct BinaryTree *tree = newTree();
	struct BinaryTree *mirror = newTree();
	/*
	         1
	       /   \
	      2     8
	     / \   / \
	    3  10 6   5
	       /   \   \
	      7     4   9
	   
	-----------------------
	    Binary Tree
	-----------------------
	*/
	tree->root = newNode(1);
	tree->root->left = newNode(2);
	tree->root->right = newNode(8);
	tree->root->left->left = newNode(3);
	tree->root->left->right = newNode(10);
	tree->root->left->right->left = newNode(7);
	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(9);
	printf("\n Actual Binary Tree \n");
	preorder(tree->root);
	mirror->root = createMirror(tree->root);
	/*
	         1
	       /   \
	      8     2
	     / \   / \
	    5   6 10  3
	   /   /   \
	  9   4     7
	-----------------------
	Constructed Mirror Binary Tree 
	-----------------------
	*/
	printf("\n Constructed Mirror Tree \n");
	preorder(mirror->root);
	return 0;
}

Output

 Actual Binary Tree
  1  2  3  10  7  8  6  4  5  9
 Constructed Mirror Tree
  1  8  5  9  6  4  2  10  7  3