int Depth(struct Node*node,int level)
{
   if(Node!=NULL)
    {
        if(level<depth)
         depth=level;
         Depth(Node->leftchild,level+1);
         Depth(Node->rightchild,level+1);
     }
       return(depth);
 }

int depth(treenode *p)
{
   if(p==NULL)return(0);
   if(p->left){h1=depth(p->left);}
   if(p=>right){h2=depth(p->right);}
   return(max(h1,h2)+1);
}

int depth(treenode *p)
{
   if(p==NULL)return(0);
   if(p->left){h1=depth(p->left);}
   if(p=>right){h2=depth(p->right);}
   return(max(h1,h2)+1);
}


dis is really a good program.

actually it is so efficient in time and to the point that i
hav copied it again from neetu katiyar.

#include<stdio.h>
#include<conio.h>
#include<malloc.h>
typedef struct linkedlist
{
	int data;
	struct linkedlist *left,*right;
}node;
node *makenode(int);
void setleft(node *,int);
void setright(node *,int);
void preorder(node *);
void postorder(node *);
void inorder(node *);
int depth(node *,int);
node *q,*k;
int l=0,d=1;
void main()
{
	node *root,*p,*q;
	int x,f;
	clrscr();
	printf("\nEnter the root :");
	scanf("%d",&x);
	root=makenode(x);
	printf("\nEnter the data(-1 to stop) :");
	scanf("%d",&x);
	while(x!=-1)
	{
		p=root;
		while(p!=NULL)
		{
			q=p;
			if(x<p->data)
			{
				p=p->left;
			}
			else
			{
				p=p->right;
			}
		}
		if(x<q->data)
		{
			setleft(q,x);
		}
		else
		{
			setright(q,x);
		}
		printf("\nEnter the data(-1 to stop) :");
		scanf("%d",&x);
	}
	printf("\nPreorder traversal is \n");
	preorder(root);
	printf("\nPostorder traversal is \n");
	postorder(root);
	printf("\nInorder traversal is \n");
	inorder(root);
	printf("\nDepth of the tree is \n");
	f=depth(root,l);
	printf("%d",f+1);
	getch();
}
node *makenode(int x)
{
	node * temp;
	temp=(node *)malloc(sizeof(node));
	temp->data=x;
	temp->left=NULL;
	temp->right=NULL;
	return(temp);
}
void setleft(node *p,int x)
{
	node *temp;
	if(p==NULL)
	{
		printf("Error");
	}
	temp=makenode(x);
	p->left=temp;
}
void setright(node *p,int x)
{
	node *temp;
	if(p==NULL)
	{
		printf("Error");
	}
	temp=makenode(x);
	p->right=temp;
}
void inorder(node *p)
{
	if(p!=NULL)
	{
		inorder(p->left);
		printf("%d\t",p->data);
		inorder(p->right);
	}
}
void postorder(node *p)
{
	if(p!=NULL)
	{
		postorder(p->left);
		postorder(p->right);
		printf("%d\t",p->data);
	}
}
void preorder(node *p)
{
	if(p!=NULL)
	{
		printf("%d\t",p->data);
		preorder(p->left);
		preorder(p->right);
	}
}
int depth(node *p,int l)
{
	if(p!=NULL)
	{
		if(l>d)
		d=l;
		depth(p->left,l+1);
		depth(p->right,l+1);
	}
	return d;
}

Simple way:

public int FindDepthOfTree(RBNode n)
        {
            if (n == null) return 0;
            return Math.Max(FindDepthOfTree(n.LeftNode), 
FindDepthOfTree(n.RightNode)) + 1;
        }

int depth(treenode *p)
{
   if(p==NULL)return(0);
   if(p->left){h1=depth(p->left);}
   if(p=>right){h2=depth(p->right);}
   return(max(h1,h2)+1);
}

The above code will return the number of nodes in the
longest path from root to the leaf. So subtracting with -1
will give the depth of the tree. Depth of the tree is the
distance from root to the deepest leaf.

int depth(treenode *p)
{
   if(p==NULL)return -1 ;
   if(p->left){h1=depth(p->left);}
   if(p=>right){h2=depth(p->right);}
   return(max(h1,h2)+1);
}



Check the boundary condition for p =NULL means no tree exists.
so depth should be -1 if only root node is there then depth
of the tree is 0.

int depth(treenode *p)
{
   if(p==NULL)return -1 ;
   int h1=depth(p->left);
   int h2=depth(p->right);
   return(max(h1,h2)+1);
}

in case where p has no child but is not NULL itself, it
should return 0.