Problem in question BSTOPS

[ronnith]

Can someone please tell me why is it showing wrong answer in BSTOPS for the below code. It works fine for the given test case.

#include <iostream>
#include <bits/stdc++.h>
#include <string>

using namespace std;

class node{
    public:

        int data;
        long long int pos;
        node* r_node;
        node* l_node;
        node(int d,long long int p):data{d},pos{p},r_node{nullptr},l_node{nullptr}{}
};

class BST{
    public:
        
        node* root;
        
        BST():root{nullptr}{}

        node* add_node(int d,node* focus_node,long long int p=1){
            if(focus_node==nullptr){
                focus_node=new node(d,p);
            }
            else if(focus_node->data>d){
                focus_node->l_node=add_node(d,focus_node->l_node,2*p);
            }
            else{
                focus_node->r_node=add_node(d,focus_node->r_node,2*p+1);
            }
            return focus_node;
        }

        node* find_node(int d,node* focus_node)
        {
            if(focus_node==nullptr){
                return nullptr;    
            }
            else if(focus_node->data>d){
                return find_node(d,focus_node->l_node);
            }
            else if(focus_node->data<d){
                return find_node(d,focus_node->r_node);
            }
            else{
                return focus_node;
            }
        }

        node* find_min(node* focus_node){
            if(focus_node->l_node!=nullptr){
                return find_min(focus_node->l_node);
            }
            else{
                return focus_node;
            }
        }
        
        node* find_max(node* focus_node){
            if(focus_node->r_node!=nullptr){
                return find_max(focus_node->r_node);
            }
            else{
                return focus_node;
            }
        }

        void posCorrection(node* focus_node){
            if(focus_node->r_node!=nullptr){
                (focus_node->r_node)->pos=(focus_node->pos)*2+1;
                posCorrection(focus_node->r_node);
            }
            if(focus_node->l_node!=nullptr){
                (focus_node->l_node)->pos=(focus_node->pos)*2;    
                posCorrection(focus_node->l_node);
            }
        }

        node* delete_node(int d,node* focus_node){
            if(focus_node->data>d){
                focus_node->l_node=delete_node(d,focus_node->l_node);   
            }
            else if(focus_node->data<d){
                focus_node->r_node=delete_node(d,focus_node->r_node);    
            }
            else{
                if(focus_node->r_node!=nullptr && focus_node->l_node!=nullptr){
                    node* in_post=find_min(focus_node->r_node);
                    int hd=in_post->data;
                    root=delete_node(in_post->data,root);
                    focus_node->data=hd;
                }
                else{
                    node* h=focus_node;
                    if(focus_node->r_node!=nullptr){
                        (focus_node->r_node)->pos=focus_node->pos;
                        focus_node=focus_node->r_node; 
                        posCorrection(focus_node);
                    }
                    else if(focus_node->l_node!=nullptr){
                        (focus_node->l_node)->pos=focus_node->pos;
                        focus_node=focus_node->l_node;    
                        posCorrection(focus_node);
                    }
                    else{
                        focus_node=nullptr;    
                    }
                    delete h;
                }
            }
            return focus_node;
        }
        
        void make_empty(node* focus_node){
            if(focus_node!=nullptr)
            {
                if(focus_node->r_node!=nullptr){
                    make_empty(focus_node->r_node);
                }
                if(focus_node->l_node!=nullptr){
                    make_empty(focus_node->l_node);    
                }
            }
            delete(focus_node);
        }

        ~BST(){
            make_empty(root);
        }
};

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t;
    cin>>t;
    char c;
    int x;
    BST bst;
    while(t-->0)
    {
        cin>>c;
        cin>>x;
        if(c=='i'){
            bst.root=bst.add_node(x,bst.root);
            cout<<(bst.find_node(x,bst.root))->pos<<"\n";
        }
        else{
            cout<<(bst.find_node(x,bst.root))->pos<<"\n";    
            bst.root=bst.delete_node(x,bst.root);
        }
    }
    return 0;
}