OpenGL requires a contiguous array of elements. For hopefully obvious reasons, there is no efficient way to insert a single element into a contiguous array. It is necessarily at least O(N).
However, you potentially could add N elements in less than the O(N^2) that the vector achieves for N random insertions.
For example, if you don't actually add new vertices "at any index", but always close to the previous one, you could add all the elements to a std::list (O(1) per element, O(N) total), then copy the std::list to a std::vector. In fact it doesn't have to be the previous element, just a previous element, so if the order is based on a recursive traversal of some tree then you might still be able to do this.
If new vertices are added at an index determined by some linear order, then add all the elements to a std::map or std::multi_map (O(log N) per element, O(N log N) total), then copy that to a vector.
So, the lowest-complexity way of doing it depends on how the order is determined. Whether these lower-complexity solutions are actually faster than the vector depends on N. They have much higher overheads (O(N) allocations instead of O(log N) for the vector), so N might have to be pretty big before the asymptotic behaviour kicks in.
If you do use either of the solutions I describe, then the easy/efficient way to copy either a list or a map to a vector is like this:
std::vector<glVertex3f> vec;
vec.reserve(listormap.size());
vec.insert(vec.begin(), listormap.begin(), listormap.end());