Sorting Parallel Arrays in Java

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 o

Answer 1

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.

Answer 2

A "cheap" way would be to have a third array which would contain 0 to n representing the index of the other arrays

But the problem you are having would disappear if they were grouped in a class, both information seem logically related. Then you would implement Comparable: https://stackoverflow.com/a/18896422

Answer 3

   public static void main(String[] args) {
    Integer[] bidAmount = {3000, 54000, 2000, 1000, 5600};
    String[] bidderName = {"Jenny", "Mike", "Alvin", "Berry", "John"};
    Map<Integer,String> stringTreeMap = new TreeMap<>();
    stringTreeMap.put(bidAmount[0],bidderName[0]);
    stringTreeMap.put(bidAmount[1],bidderName[1]);
    stringTreeMap.put(bidAmount[2],bidderName[2]);
    stringTreeMap.put(bidAmount[3],bidderName[3]);
    stringTreeMap.put(bidAmount[4],bidderName[4]);

    for(Map.Entry<Integer,String> entry : stringTreeMap.entrySet()) {
        Integer key = entry.getKey();
        String value = entry.getValue();

        System.out.println(key + " => " + value);
    }


}

Answer 4

If your city id is unique:

    int[] city = {3, 1, 5};
    int[] pop = {3333, 333, 33};
    Map<Integer, Integer> arr = new HashMap<Integer, Integer>(city.length);
    for (int i = 0; i < city.length; i++) {
        arr.put(city[i], pop[i]);
    }
    Arrays.sort(city);
    for (int i = 0; i < city.length; i++) {
        pop[i] = arr.get(city[i]);
    }

Answer 5

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.