Count the number of visible nodes in Binary Tree

/*
    C Program 
    Count the number of visible nodes in Binary Tree
*/
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

//Binary Tree node
struct Node
{
	int data;
	struct Node *left, *right;
};
//This is creating a binary tree node and return this
struct Node *get_node(int data)
{
	// Create dynamic node
	struct Node *new_node = (struct Node *) malloc(sizeof(struct Node));
	if (new_node != NULL)
	{
		//Set data and pointer values
		new_node->data = data;
		new_node->left = NULL;
		new_node->right = NULL;
	}
	else
	{
		//This is indicates, segmentation fault or memory overflow problem
		printf("Memory Overflow\n");
	}
	//return new node
	return new_node;
}
//Display pre order elements
void preorder(struct Node *node)
{
	if (node != NULL)
	{
		//Print node value
		printf("  %d", node->data);
		preorder(node->left);
		preorder(node->right);
	}
}
//Count visible nodes
void count_visible_nodes(struct Node *node, int sum, int *counter)
{
	if (node == NULL)
	{
		return;
	}
	int new_sum = 0;
	if (node->data >= sum)
	{
		// When get a new big node in current path
		*counter = *counter + 1;
		// get new big node
		new_sum = node->data;
	}
	else
	{
		new_sum = sum;
	}
	// Recursively visit left and right subtree
	count_visible_nodes(node->left, new_sum, counter);
	count_visible_nodes(node->right, new_sum, counter);
}
//Handles the request to find visible nodes
void visible_nodes(struct Node *root)
{
	if (root == NULL)
	{
		printf("\n Empty Tree \n");
	}
	else
	{
		//Display tree elements
		printf("\n  Tree Nodes \n");
		preorder(root);
		int counter = 0;
		count_visible_nodes(root, INT_MIN, & counter);
		// Display calculated result
		printf("\n  Output : %d \n", counter);
	}
}
int main()
{
	struct Node *root = NULL;
	/*
	constructor binary tree
	-----------------
	     8                            
	   /   \    
	  5    18    
	 / \     \               
	1   3     2  
	   / \     \
	  19  9    21
	     / \
	    12  4

	-----------------
	*/
	root = get_node(8);
	root->left = get_node(5);
	root->left->right = get_node(3);
	root->left->right->left = get_node(19);
	root->left->right->right = get_node(9);
	root->left->right->right->left = get_node(12);
	root->left->right->right->right = get_node(4);
	root->left->left = get_node(1);
	root->right = get_node(18);
	root->right->right = get_node(2);
	root->right->right->right = get_node(21);
	/*
	 Counter = 0   
	 Paths
	 {} = empty
	 8  => new big in this path  [Counter = 1]
	 8->5  => new node 5 is not big in this path
	 8->5->1 =>  new node 1 is not big in this path
	 8->5->3 =>  new node 3 is not big in this path
	 8->5->3->19 => 19 is new big in this path [Counter = 2]
	 8->5->3->9  => 9 is new big in this path [Counter = 3]
	 8->5->3->9->12  => 12 New Big in path Counter = 4
	 8->5->3->9->4 => new node 4 is not big in this path
	 8->10            = 10 is new big in this path [Counter = 5]

	 8->10->2  = new node 1 is not big in this path
	 8->10->2->21  = 21 is new big in this path [Counter = 6]


	Result = 6

	*/
	visible_nodes(root);
	return 0;
}

Output

  Tree Nodes
  8  5  1  3  19  9  12  4  18  2  21
  Output : 6