基于两个标准对列表进行排序的最佳算法是什么？

Question

I have a list which I need to sort based on two criteria. The first criterion is a Boolean , let's say isBig . The second one is a Long , which represents a timestamp.

I need to order the elements of the list in this way: before the isBig = true , and then the isBig = false . Within these groups, the single elements should be ordered descending on the basis of their timestamp.

Basically, I expect the result to be something like this:

isBig - 2015/10/29
isBig - 2015/10/28
isBig - 2015/10/27
!isBig - 2015/10/30
!isBig - 2015/10/27
!isBig - 2015/10/26

Let's say the object is this:

public class Item {
    Boolean isBig;
    Long timestamp;
    // ...
}

and the list is just List<Item> list .

I figured out that one method would be make three for-cycles: the first to make up the two groups: isBig and !isBig . The second and the third for sorting the elements within them. Finally I merge the two lists.

Is there a more efficient algorithm for sorting lists on the basis of two criteria?

Answer 1

You can sort the list directly using a custom comparison method which checks both criteria.

Use the Collections.sort method and pass a custom comparator with the method compare overriden to:

 int compare(Item o1, Item o2) {
   if (o1.isBig && !o2.isBig)
     return -1;
   if (!o1.isBig && o2.isBig)
     return 1;
   if (o1.timestamp < o2.timestamp)
     return -1;
   if (o1.timestamp > o2.timestamp)
     return 1;
   return 0;
 }

If you are obsessed with performance you could possibly speed it up by a few percents with a more sophisticated approach, but for a list of a few hundred elements the gains would be negligible.

An optimized comparison method:

int compare(Item o1, Item o2) {
   int bigness = (o2.isBig ? 2 : 0) - (o1.isBig ? 2 : 0);
   long diff = o1.timestamp - o2.timestamp;
   return bigness + (int) Long.signum(diff);
}

It features no conditional branches what means it will probably be faster than the naive version above.

That's probably everything that can be done for performance. If we knew something more about your data (for instance there are always more big object than small ones, or all the timestamps are unique, or all the timestamps are from a certain narrow range etc) we could probably propose some better solution. However, when we assume that your data is arbitrary and has no specific pattern than the very best solution is to use a standard sort utility like I've shown above.

Splitting the list into two sublists and sorting them separately will definitely be slower. Actually the sorting algorithm will most probably divide the data into two groups and then recursively into four groups, and so on. However, the division won't follow the isBig criterion. If you want to learn more, read how quick sort or merge sort work.

Answer 2

In theory, the approach using two separate lists should be faster than the approach using a two-step Comparator , because a comparison based on one field is obviously faster than a comparison based on two. By using two lists you are speeding up the part of the algorithm that has O(n log n) time complexity (the sort), at the expense of an additional initial stage (splitting into two pieces) which has time complexity O(n) . Since n log n > n , the two lists approach should be faster for very, very large values of n .

However, in practice we are talking about such tiny differences in times that you have to have extremely long lists before the two lists approach wins out, and so it's very difficult to demonstrate the difference using lists before you start running into problems such as an OutOfMemoryError .

However, if you use arrays rather than lists, and use clever tricks to do it in place rather than using separate data structures, it is possible to beat the two-step Comparator approach, as the code below demonstrates. Before anybody complains: yes I know this is not a proper benchmark!

Even though sort2 is faster than sort1 , I would probably not use it in production code. It is better to use familiar idioms and code that obviously works, rather than code that is harder to understand and maintain, even if it slightly faster.

public class Main {

    static Random rand = new Random();

    static Compound rand() {
        return new Compound(rand.nextBoolean(), rand.nextLong());
    }

    static Compound[] randArray() {
        int length = 100_000;
        Compound[] temp = new Compound[length];
        for (int i = 0; i < length; i++)
            temp[i] = rand();
        return temp;
    }

    static class Compound {
        boolean bool;
        long time;

        Compound(boolean bool, long time) {
            this.bool = bool;
            this.time = time;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) 
                return true;
            if (o == null || getClass() != o.getClass()) 
                return false;
            Compound compound = (Compound) o;
            return bool == compound.bool && time == compound.time;
        }   

        @Override
        public int hashCode() {
            int result = (bool ? 1 : 0);
            result = 31 * result + (int) (time ^ (time >>> 32));
            return result;
        }
    }

    static final Comparator<Compound> COMPARATOR = new Comparator<Compound>() {
        @Override
        public int compare(Compound o1, Compound o2) {
            int result = (o1.bool ? 0 : 1) - (o2.bool ? 0 : 1);
            return result != 0 ? result : Long.compare(o1.time, o2.time);
        }
    };

    static final Comparator<Compound> LONG_ONLY_COMPARATOR = new Comparator<Compound>() {
        @Override
        public int compare(Compound o1, Compound o2) {
            return Long.compare(o1.time, o2.time);
        }
    };

    static void sort1(Compound[] array) {
        Arrays.sort(array, COMPARATOR);
    }

    static void sort2(Compound[] array) {
        int secondIndex = array.length;
        if (secondIndex == 0)
            return;
        int firstIndex = 0;
        for (Compound c = array[0];;) {
            if (c.bool) {
                array[firstIndex++] = c;
                if (firstIndex == secondIndex)
                    break;
                c = array[firstIndex];
            } else {
                Compound c2 = array[--secondIndex];
                array[secondIndex] = c;
                if (firstIndex == secondIndex)
                    break;
                c = c2;
            }
        }
        Arrays.sort(array, 0, firstIndex, LONG_ONLY_COMPARATOR);
        Arrays.sort(array, secondIndex, array.length, LONG_ONLY_COMPARATOR);
    }

    public static void main(String... args) {

        // Warm up the JVM and check the algorithm actually works.
        for (int i = 0; i < 20; i++) {
            Compound[] arr1 = randArray();
            Compound[] arr2 = arr1.clone();
            sort1(arr1);
            sort2(arr2);
            if (!Arrays.equals(arr1, arr2))
                throw new IllegalStateException();
            System.out.println(i);
        }

        // Begin the test proper.
        long normal = 0;
        long split = 0;
        for (int i = 0; i < 100; i++) {
            Compound[] array1 = randArray();
            Compound[] array2 = array1.clone();

            long time = System.nanoTime();
            sort1(array1);
            normal += System.nanoTime() - time;

            time = System.nanoTime();
            sort2(array2);
            split += System.nanoTime() - time;

            System.out.println(i);
            System.out.println("COMPARATOR:           " + normal);
            System.out.println("LONG_ONLY_COMPARATOR: " + split);
        }
    }
}

Answer 3

The following things you need to do to have two comparable objects for sorting on two parameters.

1. You need to implement Comparator for two comparable objects that you have is one Boolean and one Timestamp.

2. you need to pass these comparators to Collections.sort() because as they are objects that compared for two keys and the data structure is not of primitives they need Collections.sort().

    /** * Comparator to sort employees list or array in order of Salary */ public static Comparator<BooleanComaprator> booleanComparator= new Comparator<BooleanComaprator>() { @Override public int compare(BooleanComaprator e1, BooleanComaprator e2) { if (e1.isBig && !e2.isBig) return -1; if (!e1.isBig && e2.isBig) return 1; else return 0; } } 

   use this object in Collections.sort(booleanComparator);

Answer 4

This is called sorting by multiple keys, and it's easy to do. If you're working with a sort library function that takes a comparator callback function to decide the relative ordering of two elements, define the comparator function so that it first checks whether the two input values a and b have equal isBig values, and, if not, immediately returns a.isBig > b.isBig (I'm assuming here that > is defined for boolean values; if not, substitute the obvious test). But if the isBig values are equal, you should return a.timestamp > b.timestamp .

Answer 5

You can a define a custom comparator and use it to sort the List . Eg

class ItemComparator implements Comparator {
    @Override
    public int compare (Item a, Item b) {
        int bc = Boolean.compare(a.isBig, b.isBig);
        if (bc != 0)
            return bc;
        return Long.compare(a.timestamp, b.timestamp);
    }
}

and use it like this

Collections.sort(list, ItemComparator);