How to efficiently sort one array by another

Question

Suppose I have the following setup:

double[] vectorUsedForSorting = new double[] { 5.8,6.2,1.5,5.4 }
double[] vectorToBeSorted = new double[] {1.1,1.2,1.3,1.4}

I would like to sort vectorToBeSorted based on the natural numerical ordering of vectorUsedForSorting.

For example, the natural ordering would be [1.5,5.4,5.8,6.2] which corresponds to indices [2,3,0,1], which would mean I want the output of the sorting function to be [1.3,1.4,1.1,1.2].

How do I do this in the most absolute efficient/fast possible way? I am mostly concerned with time-complexity since I will be doing this for 1,000,000 length arrays.

A large bonus will be awarded to a fast/efficient answer.

A) write sort B) pass both arrays C) sort both simultaneously only based on values from first. — Brian Roach
– Brian Roach, Commented Feb 7, 2014 at 21:58
Have you changed your mind w.r.t. the previous question? Now you really need sorting? — maaartinus
– maaartinus, Commented Feb 7, 2014 at 22:42

meriton · Accepted Answer · 2014-02-07 21:59:41Z

4

The simple solution:

class D implements Comparable<D> {
    double key;
    double value;

    @Override
    public int compareTo(D other) {
        return Double.compare(key, other.key);
    }
}

public class Test {
    public static void main(String[] args) {
        double[] vectorUsedForSorting = new double[] { 5.8,6.2,1.5,5.4 };
        double[] vectorToBeSorted = new double[] {1.1,1.2,1.3,1.4};

        D[] array = new D[vectorUsedForSorting.length];
        for (int i = 0; i < array.length; i++) {
            array[i] = new D();
            array[i].key = vectorUsedForSorting[i];
            array[i].value = vectorToBeSorted[i];
        }

        Arrays.sort(array);

        for (int i = 0; i < array.length; i++) {
            vectorToBeSorted[i] = array[i].value;
        }

        System.out.println(Arrays.toString(vectorToBeSorted));

    }
}

This does require a little extra memory for the auxiliary array and objects, but should come close to optimal in execution time.

answered Feb 7, 2014 at 21:59

meriton

70.9k14 gold badges117 silver badges190 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Rainbolt Over a year ago

This algorithm is O(nlogn) since Arrays.sort() is O(nlogn). This is probably as good as it gets.

user2763361 Over a year ago

This gives 560 milliseconds for 1 million datapoints. Good enough.

janek · Accepted Answer · 2014-02-07 21:52:26Z

2

Perform merge-sort on the first table, and do the same operations on the second table at the same time. Complexity nlogn guaranteed

answered Feb 7, 2014 at 21:52

janek

1841 silver badge6 bronze badges

2 Comments

user2763361 Over a year ago

Hmm I'm not sure, can you write a method? I will award bonus.

user2763361 Over a year ago

Yeah it's fine. I will write something and if it's faster than meriton I will aware you the answer. Cheers.

Collectives™ on Stack Overflow

How to efficiently sort one array by another

2 Answers 2

2 Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related