Sorting two parallel arrays

Question

I have two arrays, one stores the distance of the cities and the other stores the corresponding population. Everything works fine if the distance of the cities is in ascending order. But let say if someone inputs the distance randomly. How can I sort the cities array and also make sure that the population of the respective city is in the same index as the index of its respective city population.

For example:

• City 1 has population 333
• City 3 has population 33333
• City 5 has population 33

int[] city = {1, 3, 5};
int[] pop  = {333, 33333, 33};

Everything works fine because the city array is sorted already.

But when I input:

int[] city = {3, 1, 5};
int[] pop  = {3333, 333, 33};

Big problem!

I want sort the array city and make sure that the population array has all its elements at the same index as their respective city.

Answer 1

The good way of doing this is having a city class:

class City{
    private int id;
    private long population;

    //... getters, setters, etc
}

a city comparator class:

class CityPopulationComparator implements Comparator<City> {
    @Override
    public int compare(City c1, City c2) {
        return Long.compare(c1.getPopulation(), c2.getPopulation());
    }
}

And an array list of cities:

ArrayList<City> cities;

and finally sort it using:

Collections.sort(cities, new CityPopulationComparator());

But if you need to have your cities and populations this way, you can write a sort method yourself (a bubble sort for example) and whenever you swap two cities, also swap corresponding pupulations.

Answer 2

The correct solution is this. However if you want a completely mad hack, you can do this:

public final class ParallelIntArrays extends AbstractList<int[]> {

    private final int[] array1;
    private final int[] array2;

    public ParallelIntArrays(int[] array1, int[] array2) {
        if (array1.length != array2.length)
            throw new IllegalArgumentException();
        this.array1 = array1;
        this.array2 = array2;
    }

    @Override
    public int[] get(int i) {
        return new int[] { array1[i], array2[i] };
    }

    @Override
    public int size() {
        return array1.length;
    }

    @Override
    public int[] set(int i, int[] a) {
        if (a.length != 2)
            throw new IllegalArgumentException();
        int[] b = get(i);
        array1[i] = a[0];
        array2[i] = a[1];
        return b;
    }
}

Then you can do:

int[] city = {5,   1,  2,    4,   3   };
int[] pop =  {100, 30, 4000, 400, 5000};
new ParallelIntArrays(city, pop).sort(Comparator.comparingInt(arr -> arr[0]));
System.out.println(Arrays.toString(city));
System.out.println(Arrays.toString(pop));

Note that as written above, ParallelIntArrays does not function correctly as a List. For example list.contains(list.get(0)) would give false. If you made it a List<IntBuffer> or a List<List<Integer>> instead, it would be fixed.