How to select a random element in std::set?

Question

How can I select a random element in an std::set?

I naively tried this:

int GetSample(const std::set<int>& s) {   double r = rand() % s.size();   return *(s.begin() + r); // compile error } 

But the operator+ is not allowed in this way.

Answer 1

You could use the std::advance method.

#include <set> #include <algorithm>  int main() {   using namespace std;   // generate a set...   set<int> s;   for( int i = 0; i != 10; ++i ) s.insert(i);   auto r = rand() % s.size(); // not _really_ random   auto n = *select_random(s, r); } 

Where

template<typename S> auto select_random(const S &s, size_t n) {   auto it = std::begin(s);   // 'advance' the iterator n times   std::advance(it,n);   return it; } 

Answer 2

First Solution : O(log n) in time / O(1) in space (not uniform !)

A hypothesized in a comment above, it can be done in O(log(n)) (vs O(n) for std::advance) without a vector (using O(n) more space) by using the method I describe here.

Essentially, you :

• check if the set is empty (if it is, there is no hope)
• generate a random value
• if already there return it else insert it
• get one iterator it on it
• get the random element as *(it++) or *(set.begin()) if it at the end
• return it not before deleting the element you inserted

n.b : As pointed out by Aaron the element is not chosen uniformly at random. You need to build the random element with the same distribution than the elements in the set to approach a uniform polling.

Second Solution : O(1) in time / O(n) in space (uniform)

davidhigh already gave the solution with a vector but there is a problem because when you pop an element of your stack, you will have to perform a linear search in O(n) or you can rebuild your vector each time you want to retrieve a random element but that is O(n) too.

To avoid this problem and keep the insert/delete to O(log n), you can keep an std::unordered_set and use a similar method to the first solution to get a random element in O(1).

p.s : If your elements are large you can use an unordered set of pointers (with a modified hasher) to spare some memory.