Wymuszanie stabilnego sortowania

Question

Cześć,

mam za zadanie napisać metodę nakładkową, której rolą będzie wymuszanie stabilnego sortowania niezależnie od jego rodzaju.

W tym celu stworzyłem klasę, która ma dwa pola: jedno na obiekt wg. którego ma nastąpić sortowanie, drugi na index, który jest dołączany do każdego elementu. 

Pomysł jest taki, że przekazując dane do posortowania, metoda nakładkowa tworzy nową tablicę, której wartościami są obiekty klasy Overlay.  Następnie jest sortowanie wg. wartości kluczy. Potem metoda iteruję poprzez kolejne pola tablicy szukając takich samych elementów, jeżeli je znajduje, sortuje je wg. wartości nadanych  indexów  w klasie nakładkowej. 

Kod rozwiązania: 

Klasa nakładkowa:

public class Overlay <Key extends  Comparable<Key>> implements Comparable<Overlay> {

    private static int counter = 0;

    public int index;
   public Key item;

    public Overlay(Key item)
    {
        this.item = item;
        index = counter++;
    }

    @Override
    public String toString() {
        return  item.toString() + " " +index;
    }

    @Override
    public boolean equals(Object obj) {
        return item.equals(obj);
    }

    @Override
    public int compareTo(Overlay o) {
        return item.compareTo((Key) o.item);
    }
}

Klasa z metodą nakładkową:

public class MakeStable <Key extends  Comparable<Key>>{

    public ArrayList<Key> sort (ArrayList<Key> a )
    {
      ArrayList<Overlay<Key>> temp = new ArrayList<>();

        for (int i = 0; i < a.size(); i++)
            temp.add(new Overlay<>(a.get(i)));

      Collections.sort(temp); //sortowanie wg. kluczy
      this.makeOrder(temp);

      a = new ArrayList<>();
        for (int i = 0; i < temp.size(); i++)
            a.add(temp.get(i).item);
    return a;
    }

    private void makeOrder(ArrayList<Overlay<Key>> a)
    {
        class IndexComparator implements Comparator<Overlay> {
            @Override
            public int compare(Overlay o1, Overlay o2) {
                return Integer.compare(o1.index,o2.index);
            }
        }
        int range = 0;
        for (int i = 0; i < a.size()-1; i++)
        {
            if (a.get(i).compareTo(a.get(i+1)) == 0)
                 continue;
            else range++;

            if(i > range-1)
            {
                Collections.sort(a.subList(range-1,i+1),new IndexComparator()); //sortowanie równych elementów wg. wartości indexów
                range = i+1;
            }
        }
    }
}

Czy przedstawione przeze mnie rozwiązanie jest waszym zdaniem poprawne? Co można było by usprawnić? 

 

Pozdrawiam :))