Which sorting algorithm is most efficient to 'continuously' sort a vector again and again? I have an uncommon use case

I have a vector, which contains a fixed number of taxi's real-time fees (the red/green number that keeps bumping up when you sit in the back).

This vector is continuously updated by message sent back from taxis. I need to find the top 10 taxis every time when there is an update.

if I only need to do this once, then std::sort() or std::partial_sort would easily solve the problem. However, since the vector is largely the same after only a few updates, the sorting result from step T should be largely the same as sorting result of step T+1

I am wondering if the std::partial_sort will be 'smart' enough to 'incrementally' sort the vector, rather than start-over again from scratch. 

Can anyone share any ideas here?

Thanks!
Look at what your problem actually is: Your problem is not sorting the list, but finding the largest ten items. That's a much easier problem, which can be solved without sorting the list again and again. 

Start by finding the top ten items once. Let $X_{10}$ be the value of the tenth largest item. 

If an item outside the top ten is changed to a value ≤ $X_{10}$, ignore it. If it is changed to a value > $X_{10}$, then drop the tenth item and insert the changed item in the array in the right position. 

If an item in the top ten is changed then move it up or down according to the new value. If the new value is less than &lt; $X_{10}$ then remove it from the top ten leaving you with the top nine, find the largest item that is currently not in the top nine, and put it into the tenth position.

So most of the time you do no work at all, a lot of the time very little work, and occasionally it takes linear time.