Position i et set?

Et set er, så vidt jeg har forstået, ofte bygget over et red-black tree - og skulle i hvert fald opføre sig nogenlunde sådan.
Hvis jeg selv koder et binært søge træ, kan jeg sagtens få "positionen" af en node i træet: Altså hvor mange noder har en værdi der er mindre og hvor mange noder har en værdi der er højre. Og det altså i tiden O(h), hvor h er højden af træet. Det er self O(log(N)), hvor N er antallet af noder i træet, hvis træet er balanceret. (Det gør jeg ved at jeg til hver node tilføjer et tal, som angiver hvor mange efterkommere noden har, og det kan opdateres så indsættelse og sletning stadig sker i O(h) )

Hvis jeg har et set, og har indsat nogle elementer kan jeg ikke lige gennemskue om der er en smart måde at gøre noget lignende på.
Altså fx:

Kode 

#include<set>

...

set<int> testSet;
testSet.insert(1);
testSet.insert(3);
testSet.insert(7);
testSet.insert(15);
testSet.insert(31);
testSet.insert(63);
testSet.insert(127);

I testSet skulle 31 så have position nr. 5 (Eller 4 hvis man 0-indekserer)
Så: Hvordan finder jeg ud af det i logaritmisk tid?

PS: Jeg spørger fordi jeg gerne vli bruge det til konkurrencer, hvor vi ikke får lov til at genbruge tidligere kode, så derfor det lidt mærkelig spørgsmål.

Rod knuden har index 0. Enhver knude har et index. En knudes venstre barn er på index '2 * i + 1' og højre barn på index '2 * (i + 1)'. En knudes parent er på index '(i - 1) / 2'.

Jeg plejer at opbygge binære træer med et array istedet for objekter med to-tre pointere (left child, right child, parent).

Kode 

template<class N>
struct Node {
    Node<N>* P; Node<N>* L; Node<N>* R;
    Node<N>** rod;
    N* noegle;
    int antal, hoejde;
    Node() { }
    Node(N* noegle1, Node<N>** rod1) { noegle = noegle1; rod = rod1; L=NULL; R=NULL; P=NULL; antal = 1; hoejde = 1; }
    int LH() { return (L!=NULL?L->hoejde:0); }
    int RH() { return (R!=NULL?R->hoejde:0); }
    int LA() { return (L!=NULL?L->antal:0); }
    int RA() { return (R!=NULL?R->antal:0); }
    void nyHoejdeOgAntal() { antal = 1 + LA() + RA(); hoejde = 1 + max(LH(),RH()); }
    int absForskel() { return abs(LH()-RH()); }
    bool ubalance() { return absForskel() == 2; }
    Node<N>* mindste() { return (L==NULL?this:L->mindste()); }
    Node<N>* stoerste() { return (R==NULL?this:R->stoerste()); }
    void rightRotate(Node<N>* X, Node<N>* Y) {
        X->P = Y->P;
        if(X->P == NULL) {
            *rod = X;
        } else {
            if(X->P->L == Y) X->P->L = X;
            if(X->P->R == Y) X->P->R = X;
        }

        Y->L = X->R;
        if(Y->L != NULL) Y->L->P = Y;

        X->R = Y;
        Y->P = X;
    }
    void leftRotate(Node<N>* X, Node<N>* Y) {
        X->P = Y->P;
        if(X->P == NULL) {
            *rod = X;
        } else {
            if(X->P->L == Y) X->P->L = X;
            if(X->P->R == Y) X->P->R = X;
        }

        Y->R = X->L;
        if(Y->R != NULL) Y->R->P = Y;

        X->L = Y;
        Y->P = X;
    }
    void balancer() {
        Node<N>* A; Node<N>* B;
        bool L1 = LH() > RH();
        if(L1) { A = L; } else { A = R; }
        bool L2 = A->LH() > A->RH();
        if(L2) { B = A->L; } else { B = A->R; }
        if(L1 && L2) {
            rightRotate(A, this);
        }
        if(!L1 && !L2) {
            leftRotate(A, this);
        }
        if(L1 && !L2) {
            leftRotate(B,A);
            rightRotate(B,this);
        }
        if(!L1 && L2) {
            rightRotate(B,A);
            leftRotate(B,this);
        }
        nyHoejdeOgAntal();
        A->nyHoejdeOgAntal();
        B->nyHoejdeOgAntal();
    }
    void balanceIgen() {
        nyHoejdeOgAntal();
        if(ubalance()) { balancer(); }
        if(P != NULL) P->balanceIgen();
    }
    void indsaet(Node<N>* ind) {
        if(*ind->noegle < *noegle) {
            if(L == NULL) {
                L = ind; ind->P = this; ind->balanceIgen();
            } else {
                L->indsaet(ind);
            }
        } else {
            if(R == NULL) {
                R = ind; ind->P = this; ind->balanceIgen();
            } else {
                R->indsaet(ind);
            }
        }
    }
    void fjern() {
        if(L == NULL && R == NULL) {
            if(P != NULL) {
                if(P->L == this) P->L = NULL;
                if(P->R == this) P->R = NULL;
                P->balanceIgen();
            } else {
                *rod = NULL;
            }
        } else {
            Node<N>* n;
            if(L != NULL) {
                n = L->stoerste();
            } else {
                n = R->mindste();
            }
            noegle = n->noegle;
            n->fjern();
        }
    }
    Node<N>* mindre_lig(N* find) {
        if(*find < *noegle) return (L!=NULL?L->mindre_lig(find):NULL);
        Node<N>* n = (R!=NULL?R->mindre_lig(find):NULL);
        return (n!=NULL?n:this);
    }
    Node<N>* stoerre_lig(N* find) {
        if(*noegle < *find) return (R!=NULL?R->stoerre_lig(find):NULL);
        Node<N>* n = (L!=NULL?L->stoerre_lig(find):NULL);
        return (n!=NULL?n:this);
    }
    int nodeTilNr(Node<N>* find) {
        if(this == find) return LA()+1;
        if(*find->noegle < *noegle) return (L!=NULL?L->nodeTilNr(find):0);
        int t = (R!=NULL?R->nodeTilNr(find):0);
        return (t==0?0:t+LA()+1);
    }
};