Pomoc w algorytmie

Witam, posiadam tablicę obiektów z czego każdy ma kilka atrybutów (m.in. rodzaj biegacza, prędkość, aktualny dystans), oraz metodę poruszaj się. .
Mam problem z napisaniem klasy, bądź funkcji, która będzie odnajdywała obiekty które wyprzedzają inny obiekt. Potrzebuję to ponieważ prędkość obiektu wyprzedzonego ma się zmieniać (stan poszczególnych biegaczy rejestrowany jest z dokładnością 1 poruszenia). Czy mógłby ktoś podsunąć jakąś idee napisania takiej klasy/funkcji ?
Dodam, że myślałem już nad kopią tablicy z przed poruszeniem i po poruszeniu się obiektów.

Sortuj tablicę wskaźników na obiekty po ich po ich pozycji (albo prędkości).

W wariancie bardziej zaawansowanym użyj Boost.MultiIndex gdzie jednym z posortowanych indeksów będzie prędkość/dystans.

Rozumiem, tylko mając dwie posortowane tablice, po aktualnym dystansie, sprawdzam czy są sobie równe, ale napotykam na sytuację: (załącznik)

Jaki algorytm mógłbym zastosować ?

UP. Poszukuję pomocy, w realizacji tej funkcji/klasy.

pomocy? czyli już coś zrobiłeś? Pokaż co.

Generalnie brakuje mi tylko funkcji która będzie sprawdzała czy obiekty się wyprzedzają i dokonywała zmian w prędkościach danego obiektu.
Program mam napisany, obiekty są generowane dynamicznie do tablicy wskaźników. Symulacja wyścigu działa również, aczkolwiek nie sprawdza czy obiekty się nie "wyprzedzają", na koniec program wyświetla poszczególne miejsca i statystyki.

Zamieszczam kawałek kodu z bazowym zawodnikiem oraz jednym dziedziczącym, oraz kod źródłowy symulacji wyścigu.

class Bazowy_zawodnik {
    friend class Symuluj_wyscig;
protected:
    int rodzaj_zwierzecia ;  // 0-slimak 1-stonoga 2-zolw 3-domyslna_inicjalizacja
    int grupa;               // po 10 max w grupie 0-domyslna_inicjalizacja
    double predkosc    ;      // predkosc biegu 0-domysl.inicjalizacja
    float aktualny_dystans;  // gdzie aktualnie znajduje sie obiekt
    int koniec_wyscigu ;// 1tak 0nie czy ukonczyl wyscig (meta lub rozbicie)
    int miejsce ;
public:
    Bazowy_zawodnik(int=3, int=0, int=0, int=0, int=0, int=0);
    virtual void wypisz();
    virtual void uzupelnij(int ilosc_w_grupie);
    virtual void poruszaj_sie (int droga);
    friend Bazowy_zawodnik** stworz_tablice_zawodnikow(int ile);
};


class Slimak: public Bazowy_zawodnik {
protected:
    int ilosc_slimakow_w_grupie ;   // ilosc slimakow w grupie
    int dobiegl_do_mety ;    // 1tak 0nie czy dobiegl do mety

public:
    Slimak (int=0, int=0, int=5, int=0, int=0, int=0, int=0, int=0);
    virtual void wypisz ();
    virtual void poruszaj_sie (int droga);
    virtual void uzupelnij(int ilosc_w_grupie);
};

Bazowy_zawodnik** stworz_tablice_zawodnikow (int ile) {
    Bazowy_zawodnik** tablica = new Bazowy_zawodnik*[ile] ;
    srand(time(NULL));
    int licznik_elemntow=0;
    int ilosc_slimakow = 0;
    int ilosc_zolwi = 0;
    int indeks =0 ;
    int indeks2 = 0 ;

    for (int i=0;i<ile;i++) {
        int losowa = rand()%3;
        if (losowa == 0) tablica[i] = new Slimak();
        else if (losowa == 1) tablica[i] = new Stonoga();
        else tablica[i] = new Zolw();
        tablica[i]->grupa = i/10 ;
    }
    while (licznik_elemntow<ile) {
        while ((licznik_elemntow % 10 !=0 )||(licznik_elemntow==0))  {
            if (tablica[indeks]->rodzaj_zwierzecia==0) ilosc_slimakow ++;
            if (tablica[indeks]->rodzaj_zwierzecia==2) ilosc_zolwi ++;
            if (licznik_elemntow>=ile) break;
            indeks++;
            licznik_elemntow++;
        }
        for (int i=indeks2;i<licznik_elemntow;i++) {
            if (tablica[indeks2]->rodzaj_zwierzecia==0) tablica[indeks2]->uzupelnij(ilosc_slimakow);
            if (tablica[indeks2]->rodzaj_zwierzecia==2) tablica[indeks2]->uzupelnij(ilosc_zolwi);
            indeks2++;
        }
        ilosc_slimakow = 0;
        ilosc_zolwi=0;
        if (licznik_elemntow%10==0) {
            licznik_elemntow++;
        }
        if (licznik_elemntow>ile) break;
    }
    return tablica;
}

Potrzebowałbym jakiejś pomocy, może podpowiedzi w jaki sposób stworzyć algorytm, który będzie w stanie wychwycić wyprzedzanie się obiektów.

Możesz użyć wzorca Observer.
Każdy obiekt, który wykona krok zgłasza do observera informację o pozycji, a observer modyfikuje prędkość obiektów.