C++ 为什么我的排名二叉搜索树实现如此缓慢？

因此，我编写了一个排序自平衡二叉搜索树，而不是使用std:：set。我希望它能够更快地获得元素的排名，但它似乎比使用std:：set和迭代查找排名要花更多的时间。有没有办法加快速度

#include<bits/stdc++.h>

struct treeNode{
    int data;      
    int leftsize;  //for finding rank
    int height;    //for balancing during insertions and deletions

    treeNode* left;
    treeNode* right;

    treeNode()
    :data(NAN), leftsize(0), left(nullptr), right(nullptr){}

    treeNode(int val, int lsize, int ht)
    :data(val), leftsize(lsize), height(ht), left(nullptr), right(nullptr){}
};

int height(treeNode* node)
{
    if(node == nullptr)
        return 0;
    
    return node->height;
}

int getBalance(treeNode* node)
{
    if(node==nullptr)
        return 0;
    
    return height(node->left) - height(node->right);
}


int parseLeftSub(treeNode* node)
{
    if(node == nullptr)
        return 0;
    int cnt = 1;
    cnt += parseLeftSub(node->left);
    cnt += parseLeftSub(node->right);
    
    return cnt;
}

void printNode(treeNode* node)
{
    if(node ==  nullptr)
        return;
    
    printNode(node->left);
    std::cout << node->data << "  " << node->leftsize << std::endl;
    printNode(node->right);
}

treeNode* createNode(int val)
{
    treeNode* node = new treeNode(val, 1, 1);
    return node;
}

treeNode* createTree(std::vector<int>& a, int start, int end)
{
    if(start>end)
        return nullptr;

    int mid = (start + end)/2;

    treeNode* node = createNode(a[mid]);
    node->left = createTree(a, start, mid-1);
    node->right = createTree(a, mid+1, end);

    node->leftsize += parseLeftSub(node->left);

    return node;
}

treeNode* rightRotate(treeNode* y)  
{  
    treeNode* x = y->left;
    treeNode* T2 = x->right;
  
    // Perform rotation  
    x->right = y;  
    y->left = T2;  
  
    // Update heights  
    y->height = std::max(height(y->left), 
                    height(y->right)) + 1;  
    x->height = std::max(height(x->left), 
                    height(x->right)) + 1;  
  
    // Return new root
    y->leftsize = parseLeftSub(y->left) + 1;
    return x;  
}

treeNode* leftRotate(treeNode* x)  
{  
    treeNode* y = x->right;  
    treeNode* T2 = y->left;  
  
    // Perform rotation  
    y->left = x;  
    x->right = T2;  
  
    // Update heights  
    x->height = std::max(height(x->left),     
                    height(x->right)) + 1;  
    y->height = std::max(height(y->left),  
                    height(y->right)) + 1;  
  
    // Return new root
    y->leftsize = parseLeftSub(y->left) + 1; 
    return y;  
}  

treeNode* insertNode(int val, treeNode* node)
{
    if(node == nullptr)
        return createNode(val);

    if(val < node->data)
        node->left = insertNode(val, node->left);
    else if(val > node->data)
        node->right = insertNode(val, node->right);
    else
        return node;
    
    node->height = 1 + std::max(height(node->left), height(node->right));
    node->leftsize = parseLeftSub(node->left) + 1;
    
    int balance = getBalance(node);

    if(balance > 1 && val < node->left->data)
        return rightRotate(node);
    
    else if(balance < -1 && val > node->right->data)
        return leftRotate(node);
    
    else if(balance > 1 && val > node->left->data)
    {
        node->left = leftRotate(node->left);
        return rightRotate(node);
    }
    
    else if(balance < -1 && val < node->right->data)
    {
        node->right = rightRotate(node->right);
        return leftRotate(node);
    }

    return node;
}

treeNode* searchNode(int val, treeNode* node)
{
    if(node == nullptr)
        return nullptr;
    
    treeNode* foundNode = nullptr;
    if(val == node->data)
        return node;

    else if(val < node->data)
        foundNode = searchNode(val, node->left);
    else
        foundNode = searchNode(val, node->right);
    
    return foundNode;
}

treeNode* findLowerBound(int val, treeNode* node)
{
    if(node == nullptr)
        return nullptr;
    
    if(val == node->data)
        return node;

    else if(val>node->data)
    {
        return(findLowerBound(val, node->right));
    }

    treeNode* temp = findLowerBound(val, node->left);
    if(temp != nullptr && temp->data >= val)
        return temp;
    else
        return node; 
}

treeNode* findUpperBound(int val, treeNode* node)
{
    if(node == nullptr)
        return nullptr;
    
    if(val == node->data)
        return node;

    else if(val<node->data)
    {
        return(findUpperBound(val, node->left));
    }

    treeNode* temp = findUpperBound(val, node->right);
    if(temp != nullptr && temp->data <= val)
        return temp;
    else
        return node; 
}

treeNode* findMinNode(treeNode* node)
{
    if(node->left == nullptr)
        return node;
    return (findMinNode(node->left));
}

treeNode* deleteNode(int val, treeNode*& node)
{
    if(node == nullptr)
        return nullptr;

    if(node->data > val)
        node->left = deleteNode(val, node->left);
    else if(node->data < val)
        node->right = deleteNode(val, node->right);
    else
    {
        if(node->left==nullptr && node->right==nullptr)
        {
            delete node;
            node = nullptr;
        }

        else if(node->left==nullptr)
        {
            treeNode* temp = node;
            node = node->right;
            delete temp;
        }
        else if(node->right==nullptr)
        {
            treeNode* temp = node;
            node = node->left;
            delete temp;
        }
        else
        {
            treeNode* temp = findMinNode(node->right);
            node->data  = temp->data;
            node->right = deleteNode(temp->data, node->right);
        }
    }    

    if (node == NULL)  
        return node;
    
    node->leftsize = parseLeftSub(node->left) + 1;
    node->height = 1 + std::max(height(node->left),  
                           height(node->right));  

    int balance = getBalance(node);  
  
    if (balance > 1 &&  
        getBalance(node->left) >= 0)  
        return rightRotate(node);  
  
    if (balance > 1 &&  
        getBalance(node->left) < 0)  
    {  
        node->left = leftRotate(node->left);  
        return rightRotate(node);  
    }  

    if (balance < -1 &&  
        getBalance(node->right) <= 0)  
        return leftRotate(node);  

    if (balance < -1 &&  
        getBalance(node->right) > 0)  
    {  
        node->right = rightRotate(node->right);  
        return leftRotate(node);  
    }  
    
    return node;
}

int findRank(int val, treeNode* node)
{
    int rank = node->leftsize;
    if(node==nullptr)
    {
        return -1;
    }

    if(val<node->data)
    {
        rank -= node->leftsize;
        rank += findRank(val, node->left);
    }
    else if(val>node->data)
    {
        rank += findRank(val, node->right);
    }

    return rank;    
}

#包括
树状结构{
int数据；
int leftsize；//用于查找秩
int height；//用于在插入和删除期间进行平衡
treeNode*左；
treeNode*对；
treeNode（）
：data（NAN）、leftsize（0）、left（nullptr）、right（nullptr）{
treeNode（内部val、内部lsize、内部ht）
：data（val）、leftsize（lsize）、height（ht）、left（nullptr）、right（nullptr）{
};
内部高度（treeNode*节点）
{
if（node==nullptr）
返回0；
返回节点->高度；
}
int getBalance（树节点*node）
{
if（node==nullptr）
返回0；
返回高度（节点->左）-高度（节点->右）；
}
int parseLeftSub（treeNode*节点）
{
if（node==nullptr）
返回0；
int-cnt=1；
cnt+=parseLeftSub（节点->左）；
cnt+=parseLeftSub（节点->右侧）；
返回cnt；
}
void printNode（treeNode*节点）
{
if（node==nullptr）
返回；
打印节点（节点->左侧）；
std:：cout（数据端）
返回空ptr；
int mid=（开始+结束）/2；
treeNode*node=createNode（a[mid]）；
node->left=createTree（a，start，mid-1）；
node->right=createTree（a，mid+1，end）；
node->leftsize+=parseLeftSub（node->left）；
返回节点；
}
treeNode*右旋转（treeNode*y）
{  
树节点*x=y->左；
树节点*T2=x->右侧；
//轮换
x->右=y；
y->左=T2；
//更新高度
y->高度=标准：：最大（高度（y->左侧），
高度（y->右））+1；
x->高度=标准：：最大（高度（x->左侧），
高度（x->右））+1；
//返回新根
y->leftsize=parseLeftSub（y->left）+1；
返回x；
}
treeNode*leftRotate（treeNode*x）
{  
树节点*y=x->右侧；
树节点*T2=y->左；
//轮换
y->左=x；
x->右=T2；
//更新高度
x->高度=标准：：最大（高度（x->左侧），
高度（x->右））+1；
y->高度=标准：：最大（高度（y->左侧），
高度（y->右））+1；
//返回新根
y->leftsize=parseLeftSub（y->left）+1；
返回y；
}  
treeNode*插入节点（int val，treeNode*节点）
{
if（node==nullptr）
返回createNode（val）；
if（valdata）
节点->左=插入节点（val，节点->左）；
else if（val>节点->数据）
节点->右侧=插入节点（val，节点->右侧）；
其他的
返回节点；
节点->高度=1+std:：max（高度（节点->左侧）、高度（节点->右侧））；
node->leftsize=parseLeftSub（node->left）+1；
int balance=getBalance（节点）；
如果（余额>1&&valleft->data）
返回右旋转（节点）；
else if（余额<-1&&val>节点->右侧->数据）
返回leftRotate（节点）；
else if（余额>1&&val>节点->左侧->数据）
{
节点->左=左旋转（节点->左）；
返回右旋转（节点）；
}
else if（余额<-1&&val<节点->右侧->数据）
{
节点->右=右旋转（节点->右）；
返回leftRotate（节点）；
}
返回节点；
}
treeNode*搜索节点（int val，treeNode*节点）
{
if（node==nullptr）
返回空ptr；
treeNode*foundNode=nullptr；
if（val==节点->数据）
返回节点；
else if（valdata）
foundNode=searchNode（val，节点->左）；
其他的
foundNode=searchNode（val，节点->右侧）；
返回foundNode；
}
treeNode*findLowerBound（int val，treeNode*节点）
{
if（node==nullptr）
返回空ptr；
if（val==节点->数据）
返回节点；
else if（val>节点->数据）
{
返回（findLowerBound（val，node->right））；
}
treeNode*temp=findLowerBound（val，节点->左侧）；
if（temp！=nullptr&&temp->data>=val）
返回温度；
其他的
返回节点；
}
treeNode*findUpperBound（int val，treeNode*节点）
{
if（node==nullptr）
返回空ptr；
if（val==节点->数据）
返回节点；
else if（valdata）
{
返回（findUpperBound（val，node->left））；
}
树节点*temp=findUpperBound（val，节点->右侧）；
if（temp！=nullptr&&temp->data left==nullptr）
返回节点；
返回（findMinNode（节点->左））；
}
treeNode*删除节点（int val、treeNode*&节点）
{
if（node==nullptr）
返回空ptr；
如果（节点->数据>值）
节点->左=删除节点（val，节点->左）；
else if（节点->数据右侧=删除节点（val，节点->右侧）；
其他的
{
if（node->left==nullptr&&node->right==nullptr）
{
删除节点；
node=nullptr；
}
else if（节点->左==nullptr）
{
树节点*temp=节点；
节点=节点->右侧；
删除临时文件；
}
else if（节点->右侧==nullptr）
{
树节点*temp=节点；
节点=节点->左；
删除临时文件；
}
其他的
{
treeNode*temp=findMinNode（节点->右侧）；
节点->数据=临时->数据；
节点->右侧=删除节点（临时->数据，节点->右侧）；
}
}    
if（node==NULL）
返回节点；
node->leftsize=parseLeftSub（node->left）+1；
节点->高度=1+std:：max（高度（节点->左侧），
高度（节点->右侧）；
int balance=getBalance（节点）；
如果（余额>1&&
getBalance（节点->左）>=0）
返回右旋转（节点）；
如果（余额>1&&
getBalance（节点->左）<0）
{  
节点->左=左旋转（节点->左）；
返回右旋转（节点）；
}  
如果（余额<-1&&