Print leftmost and rightmost nodes of a binary tree

/*
   C Program 
   Print leftmost and rightmost nodes of a binary tree
*/
#include <stdio.h>
#include <stdlib.h>

struct TreeNode
{
	int key;
	struct TreeNode *left;
	struct TreeNode *right;
};
struct BinaryTree
{
	struct TreeNode *root;
};
struct QNode
{
	struct TreeNode *n;
	struct QNode *next;
};
struct MyQueue
{
	int size;
	struct QNode *front;
	struct QNode *rear;
};
struct BinaryTree *makeTree()
{
	struct BinaryTree *tree = (struct BinaryTree *) malloc(sizeof(struct BinaryTree));
	if (tree == NULL)
	{
		printf("\nMemory Overflow, when creating a new BinaryTree\n");
	}
	else
	{
		tree->root = NULL;
	}
	return tree;
}
struct MyQueue *makeQueue()
{
	// Create dynamic node of MyQueue
	struct MyQueue *q = (struct MyQueue *) malloc(sizeof(struct MyQueue));
	if (q == NULL)
	{
		printf("\n Memory Overflow, when creating a new Queue\n");
	}
	else
	{
		q->front = NULL;
		q->rear = NULL;
		q->size = 0;
	}
	return q;
}
int isSize(struct MyQueue *queue)
{
	return queue->size;
}
struct TreeNode *peek(struct MyQueue *q)
{
	if (isSize(q) == 0)
	{
		printf("\n Empty Queue");
		return NULL;
	}
	return q->front->n;
}
// Add new queue node
void enqueue(struct MyQueue *q, struct TreeNode *element)
{
	// Make a new Queue node
	struct QNode *node = (struct QNode *) malloc(sizeof(struct QNode));
	if (node != NULL)
	{
		// Set node values
		node->n = element;
		node->next = NULL;
		if (q->front == NULL)
		{
			q->front = node;
			q->rear = q->front;
		}
		else
		{
			q->rear->next = node;
			q->rear = node;
		}
		q->size++;
	}
	else
	{
		printf("\nMemory Overflow, when creating a new Queue Node\n");
	}
}
// Remove a queue elements
void dequeue(struct MyQueue *q)
{
	if (isSize(q) > 0)
	{
		struct QNode *remove = q->front;
		if (q->front == q->rear)
		{
			q->rear = NULL;
		}
		q->front = q->front->next;
		q->size = q->size - 1;
		remove->n = NULL;
		remove->next = NULL;
		//free node
		free(remove);
		remove = NULL;
	}
}
// 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->key = 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;
}
void cornerNode(struct TreeNode *root)
{
	struct MyQueue *q = makeQueue();
	// Insert first node of queue
	enqueue(q, root);
	int n = 0;
	int start = 0;
	// Define some auxiliary variable
	struct TreeNode *node = NULL;
	struct TreeNode *auxiliary = NULL;
	while (isSize(q) > 0)
	{
		// Get current queue size
		n = isSize(q);
		start = 1;
		while (n > 0)
		{
			node = peek(q);
			// Remove front node of queue 
			dequeue(q);
			if (node->left != NULL)
			{
				enqueue(q, node->left);
			}
			if (node->right != NULL)
			{
				enqueue(q, node->right);
			}
			// Reduce size
			n--;
			if (n == 0 || start == 1)
			{
				// Print first and last node of tree level
				printf("%d ", node->key);
				start = 0;
			}
		}
		// When change level
		printf("\n");
	}
}
int main(int argc, char
	const *argv[])
{
	struct BinaryTree *tree = makeTree();
	/*
	    
	         1
	       /   \
	      2     5
	     / \   / \
	    3   4 6   7
	       / \   /
	      8   9 10 
	    ---------------
	    Binary Tree

	*/
	tree->root = newNode(1);
	tree->root->left = newNode(2);
	tree->root->left->left = newNode(3);
	tree->root->left->right = newNode(4);
	tree->root->left->right->left = newNode(8);
	tree->root->left->right->right = newNode(9);
	tree->root->right = newNode(5);
	tree->root->right->left = newNode(6);
	tree->root->right->right = newNode(7);
	tree->root->right->right->left = newNode(10);
	// Corner Node (1,2,5,3,7,8,10)
	cornerNode(tree->root);
	return 0;
}

Output

1
2 5
3 7
8 10