Sum of cousin nodes of a given node in a BST

/*
    C Program 
    Sum of cousin nodes of a given node in a BST
*/
#include <stdio.h>
#include <stdlib.h>

// Tree Node
struct TreeNode
{
	int data;
	struct TreeNode *left;
	struct TreeNode *right;
};
// Binary Search Tree
struct BinarySearchTree
{
	struct TreeNode *root;
};
// Create new tree
struct BinarySearchTree *newTree()
{
	// Create dynamic node
	struct BinarySearchTree *tree = 
      (struct BinarySearchTree *) malloc(sizeof(struct BinarySearchTree));
	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 *newTreeNode(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;
}
// Adding a new node in binary search tree
void addNode(struct BinarySearchTree *tree, int data)
{
	struct TreeNode *node = newTreeNode(data);
	if (node != NULL)
	{
		if (tree->root == NULL)
		{
			tree->root = node;
		}
		else
		{
			struct TreeNode *auxiliary = tree->root;
			// Add new node in binary search tree
			while (auxiliary != NULL)
			{
				if (data > auxiliary->data)
				{
					if (auxiliary->right == NULL)
					{
						// Add new node at right child
						auxiliary->right = node;
						return;
					}
					auxiliary = auxiliary->right;
				}
				else
				{
					if (auxiliary->left == NULL)
					{
						// Add new node at left child
						auxiliary->left = node;
						return;
					}
					auxiliary = auxiliary->left;
				}
			}
		}
	}
}
struct TreeNode *findParent(int value, 
                            struct TreeNode *node, 
                            int count, 
                            int *level)
{
	if (node != NULL)
	{
		if ((node->left != NULL && node->left->data == value) || 
            (node->right != NULL && node->right->data == value))
		{
			// Find level of node
			*level = count + 1;
			// Returns the parent of the data
			return node;
		}
		struct TreeNode *p = NULL;
		// Find node value in left subtree
		p = findParent(value, node->left, count + 1, level);
		if (p == NULL)
		{
			// When need to find node value in right subtree
			p = findParent(value, node->right, count + 1, level);
		}
		return p;
	}
	return NULL;
}
int cousinSum(struct TreeNode *node, 
              struct TreeNode *parent, int level, int position)
{
	if (node != NULL && node != parent && position <= level)
	{
		if (position == level)
		{
			return node->data;
		}
		// Sum of cousin node
		return cousinSum(node->left, parent, level, position + 1) +
          cousinSum(node->right, parent, level, position + 1);
	}
	return 0;
}
void findCousinSum(struct TreeNode *root, int node)
{
	printf("\n Given node value : %d\n", node);
	if (root->data == node)
	{
		printf("Result : 0\n");
		return;
	}
	int level = -1;
	struct TreeNode *p = findParent(node, root, 0, & level);
	if (p == NULL)
	{
		// Given node not present
		printf(" Result : node not exists\n");
	}
	else
	{
		int sum = cousinSum(root, p, level, 0);
		// Display cousin sum
		printf(" Result : %d\n", sum);
	}
}
int main()
{
	struct BinarySearchTree *tree = newTree();
	/*
	            15
	           / \ 
	          /   \ 
	         /     \
	        13      20
	       /  \     / \
	      12  14   18  21
	     /        /  \   \
	    11       16  19   22
	              \
	               17
	    -----------------------
	    Binary search tree         
	*/
	// Add node
	addNode(tree, 15);
	addNode(tree, 13);
	addNode(tree, 12);
	addNode(tree, 14);
	addNode(tree, 11);
	addNode(tree, 20);
	addNode(tree, 18);
	addNode(tree, 19);
	addNode(tree, 21);
	addNode(tree, 22);
	addNode(tree, 16);
	addNode(tree, 17);
	// Test A
	/*
	            15
	           / \ 
	          /   \ 
	         /     \
	        13      20
	       /  \     / \
	      12  14 → 18  21 ←
	     /        /  \   \
	    11       16  19   22
	              \
	               17
	    -----------------------
	    Node : 14

	    Cousin : [18 + 21] = 39      
	*/
	findCousinSum(tree->root, 14);
	// Test B
	/*
	            15
	           / \ 
	          /   \ 
	         /     \
	        13      20
	       /  \     / \
	      12  14   18  21 
	     /        /  \   \
	  → 11    → 16  → 19  22
	              \
	               17
	    -----------------------
	    Node : 22

	    Cousin : [11 + 16 + 19] = 46      
	*/
	findCousinSum(tree->root, 22);
	// Test C
	/*
	            15
	           / \ 
	          /   \ 
	         /     \
	        13      20 ←
	       /  \     / \
	      12  14   18  21 
	     /        /  \   \
	    11      16    19  22
	              \
	               17
	    -----------------------
	    Node : 17
	    Cousin : None = 0  
	
	*/
	findCousinSum(tree->root, 17);
	// Test D
	/*
	            15
	           / \ 
	          /   \ 
	         /     \
	        13      20
	       /  \     / \
	      12  14   18  21 
	     /        /  \   \
	    11      16    19  22
	              \
	               17
	    -----------------------
	    Node : 13

	    Cousin : None = 0     
	*/
	findCousinSum(tree->root, 13);
	// Test E
	/*
	            15
	           /  \ 
	          /    \ 
	         /      \
	        13      20
	       /  \     / \
	   → 12   14 ← 18  21 
	     /        /  \   \
	    11      16    19  22
	              \
	               17
	    -----------------------
	    Node : 21

	    Cousin : [12 + 14] = 26     
	*/
	findCousinSum(tree->root, 21);
	findCousinSum(tree->root, 8);
	return 0;
}

Output

 Given node value : 14
 Result : 39

 Given node value : 22
 Result : 46

 Given node value : 17
 Result : 0

 Given node value : 13
 Result : 0

 Given node value : 21
 Result : 26

 Given node value : 8
 Result : node not exists