在C ++中，映射比堆有什么优势

Question

currently i am doing problem on data structure and i have a question in which i have to find kth largest element in an array. the actual problem is here: https://www.geeksforgeeks.org/kth-smallestlargest-element-unsorted-array/ .

i did this question in two different way using heap and second is using map.

my solution using map.

   int t;
cin>>t;
while(--t>=0){
int n,k;
cin>>n;
vector<int> A(n);
for(int i=0;i<n;i++){
cin>>A[i];
 }
cin>>k;
map<int,int> m;
for(int i=0;i<n;i++){
    m[A[i]]++;
}
auto it=m.begin();
for(int i=1;i<=k-1;i++){
    it++;
}
cout<<it->first<<endl;

but my map solution is giving Time Limit Exceeded. according to me map solution also has a time complexity of (n+klog(n)), same as heap solution. so why is map solution giving TLE?

Answer 1

Without seeing your heap version I would guess the map's allocation is the cause of the trouble. Each node needs an allocation, which implies a lock and some additional management.

And you have to follow the pointers internally in the map data structure, which is usually not the case in heaps.

In big O notation this doesn't add anything to the time, but in practice each can slow down the program by a large factor.

Answer 2

The time complexity for your solution using maps would be O(k + nlog(n)). Each insertion into std::map takes log(n) time and you are performing 'n' insertions. Time complexity for insertion alone would take O(nlog(n)) time.

See http://www.cplusplus.com/reference/map/map/insert/ for more information about inserting elements into std::map .

Answer 3

A simple improvement to the algorithm is that there is a "trick": * If you only need to print "k" elements, then you only need to remember the "k" biggest elements. That way the insert operations never exceed O(log k) rather than O(log n). And k is presumably much less than n...

So instead of inserting everything into a map that gets bigger and bigger (and slower and slower - you mention a time-restriction). Change the code to remove the smallest element in the map once (map.size() >= k):

    map<int,int> m;
    for(int i = 0; i < n ; i++) {
        m[A[i]]++;
        if(m.size() > k) {           // <<<<<<<<
             m.erase(m.begin())      // <<<<<<<<
        }
    }