为重复的 Java 优化 QuickSort 分区

Question

I'm trying to optimize my partition algorithm to sort arrays full of duplicate elements faster since it goes in a sort of infinite loop if the array is ALL duplicates. The only thing I can think of is doing firstunknown++ every time any adjacent elements are duplicates but I have no idea where or how to implement that in my code.

Any help would be appreciated, thank you.

Answer 1

One solution might be to remove duplicates, then do quick sort, and then add them back. The removal and addition of duplicates can be done in linear time.

Removing duplicates

This method removes duplicates from the given array and returns a map of <number in array, count>:

public static Map<Integer, Integer> removeDuplicates(Integer[] arr) {
    
    LinkedList<Integer> duplicatesRemoved = new LinkedList<>();
    HashMap<Integer, Integer> counts = new HashMap<>();
    
    for (Integer n: arr) {
        if (counts.containsKey(n)) {
            counts.put(n, counts.get(n)+1);
        } else {
            counts.put(n, 1);
            duplicatesRemoved.add(n);
        }
    }
    
    return duplicatesRemoved.toArray(new Integer[0]);
}

Adding duplicates back into sorted array

Once you do your quicksort, you can add the duplicates back in (again, in linear time):

public static Integer[] expand(Integer[] arr, HashMap<Integer, Integer> counts) {
      
    LinkedList<Integer> expanded = new LinkedList<>();
      
    for (Integer n: arr) {
        Integer count = counts.get(n);
        for (int i=0; i < count; i++) {
            expanded.add(n);
        }
    }
      
    return expanded.toArray(new Integer[0]);
}

This will save you complex work in handling duplicates within the sort.

Answer 2

Have you considered using 3-way partition quick sort? it works faster if there are duplicates. https://medium.com/@nehasangeetajha/3-way-quick-sort-18d2dcc5b06b

private static void quickSort(int[] arr, int l,int r){
    if(l >= r){
        return;
    }
    int value = arr[l];
    int lt = l;
    int gt = r;
    int i = l+1;
    while(i <= gt){
        if(arr[i] < value){
            swap(arr, i++, lt++);
        }
        else if(arr[i] > value){
            swap(arr,i, gt--);
        }
        else{
            i++;
        }
    }
    quickSort(arr, l, lt-1);
    quickSort(arr, gt+1, r);
}