C++ 用二叉搜索树查找数组中第k个最小元素

问题是找到数组中的“第k个”最小元素。

现在我确实看到了给定的技术，但无法正确理解它们。看到这个问题后，我的第一个直觉是从给定数组创建一个BST，并使用BST的顺序遍历来查找数组中的“第k个”最小元素。以下是我的方法代码

/*

#包括
使用名称空间std；
结构节点{
int数据；
节点*左；
节点*右；
};
向量v//排序向量
节点*插入（节点*根，整数数据）{
如果（！root）{
根=新节点（）；
根->数据=数据；
根->左=空；
root->right=NULL；
返回根；
}
如果（根->数据>数据）
根->左=插入（根->左，数据）；
其他的
根->右=插入（根->右，数据）；
返回根；
}
无效索引（节点*根）{
如果（！root）
返回；
顺序（根->左）；
v、 向后推（根->数据）；
//库特；
而（t--）{
node*root=NULL；
int n，el；
cin>>n；
对于（int i=0；i>el；
根=插入（根，el）；
}
int k；
cin>>k；
顺序（根）；
你不能用BST来解决这个问题

问题cleary指出预期时间复杂度：O（N）

但是插入操作本身取平均值O（logN），最差值O（N）。
您正在执行N次插入操作。因此

for（int i=0；i>el；
根=插入（根，el）；
}

此代码片段已采用O（NlogN）或最差O（N^2）

与快速排序一样，使用透视和分区

但是，不是对数组进行完全排序，而是丢弃一个不相关的分区，只在一个分区上递归地保留分区。

查看“最佳解决方案”链接以获取详细信息。
最坏情况下，您的代码不是O（n），而是O（n*2），平均值是O（n*logn）。我希望TLE发生在故意选择的数据上，以显示最坏情况行为。最坏情况会发生在（例如）当您的BST将退化为链表时，已经对数据进行了排序。这是BST的一个众所周知的问题。好消息是，如果效率低下，代码似乎是正确的。为什么是O（n^2）？是因为每次插入都是O（n）并调用它“n”次，使其成为O（n^2）那么这个方法就不能用了？就是这样，排序后的数据就是这样。在上面的评论中输入错误。当然我指的是O（n^2），即二次时间，而不是O（n*2）。是O（n），你可以用它。
#include <bits/stdc++.h>
using namespace std;
struct node{
    int data;
    node* left;
    node* right;
};
vector<int> v;//sorted vector
node* insert(node* root,int data){
    if(!root){
        root = new node();
        root->data = data;
        root->left = NULL;
        root->right = NULL;
        return root;
    }
    if(root->data > data)
    root->left = insert(root->left , data);
    else
    root->right = insert(root->right , data);
    
    return root;
}
void inOrder(node* root){
    if(!root)
    return;
    
    inOrder(root->left);
    v.push_back(root->data);
    //cout<<root->data<<" ";
    inOrder(root->right);
}
int main() {
    int t;
    cin>>t;
    while(t--){
        node* root = NULL;
        int n,el;
        cin>>n;
        for(int i=0;i<n;i++){
            cin>>el;
            root = insert(root,el);
        }
        int k;
        cin>>k;
        inOrder(root);
        cout<<v[k-1]<<endl;
        v.clear();
    }
    return 0;
}

for(int i=0;i<n;i++){
  cin>>el;
  root = insert(root,el);
}