CareerCup

struct node{
    int info;
    struct node *leftch;
    struct node *rightch;
};


int AppendInBST(struct node **start, int num)
{
    struct node *ptr,*tmp,*par=NULL;
    tmp = (struct node*)malloc(sizeof(struct node));
    tmp->info = num;
    tmp->leftch= NULL;
    tmp->rightch = NULL;

    ptr = *start;
    while(ptr != NULL)
    {
        par = ptr;
        if(num > ptr->info)
            ptr = ptr->rightch;
        else if(num < ptr->info)
            ptr = ptr->leftch;
        else{
            printf("Duplicate Entry\n");
            return 0;
        }
    }
    if(par == NULL)
    {
        *start = tmp;
    }
    else if(par->info > num)
        par->leftch= tmp;
    else if((par->info) < num)
        par->rightch = tmp;
    return 1;
}

How about this one? Since once mention the Btree I always think of recursive

struct node{
    int data;
    node *leftch;
    node *rightch;
    };
    
    void intoatree(struct node **root, int n){
        node *temp=new node; 
        (*temp).data=n;
        (*temp).leftch=NULL;
        (*temp).rightch=NULL;
        
        node **par;
        
        par=root;
    
        
        if(*root==NULL){
            *root=temp; //insert as the first node
        }
        else if((*(*par)).data==n){
            cout<<"duplicate input"<<endl;
            return;
        }
        else if((*(*par)).data>n){
            *par=(*(*par)).leftch;
            intoatree(par,n);
        }
        else{
            *par=(*(*par)).rightch;
            intoatree(par,n);
        }
        
    }

how about this?

TreeNode* insertNode(TreeNode *root, TreeNode *newNode) {
	if (root == NULL) {
		// if there is no root, use current one as root
		return newNode;
	}

	if (newNode->val >= root->val) {
		root->right = insertNode(root->right, newNode);
	} else {
		root->left = insertNode(root->left, newNode);
	}
	return root;
}