你如何实现快速排序以降序排序（java）？

Question

This current quicksort implementation will sort an array to be in ascending order. How do I change this code so that it will sort an array to be in descending order? I need some help reversing the logic. Advice would be much appreciated.

    public void quickSort(int[] array) {
    
    // An array of size 1 is already sorted                                                                             
    if (array.length < 2)
        return;
    
    // Find the largest element and put it at the end of the array                                                      
    int max = 0;
    for (int i = 1; i < array.length; i++) {
        if (array[i] > array[max]) {
            max = i;
        }
    }
    swap(array, array.length-1, max);
    
    // Call the main quicksort method                                                                                   
    quicksort(array, 0, array.length-1);
}

public void quicksort(int[] array, int first, int last) {
    
    int lower = first + 1, upper = last;
    
    // Use the middle array element as the bound (pivot) and                                                            
    // move it out of the way into the first array element                                                              
    swap(array, first, (first + last)/2);
    int bound = array[first];
    
    // Partition the array                                                                                              
    while (lower <= upper) {
        while (array[lower] < bound) {
            lower++;
        }
        while (array[upper] > bound) {
            upper--;
        }
        if (lower < upper) {
            swap(array, lower++, upper--);
        }
        else {
            lower++;
        }
    }
    
    // Move the pivot into its proper position in the array                                                             
    swap(array, upper, first);
    
    // Recursively sort the lower and upper subarrays                                                                   
    if (first < upper-1) {
        quicksort(array, first, upper-1);
    }

    if ((upper+1) < last) {
        quicksort(array, upper+1, last);
    }
}

Answer 1

So the basic concept would be to modify...

while (array[lower] < bound) {
    lower++;
}
while (array[upper] > bound) {
    upper--;
}

to match your requirements, but it's not particularly reusable. Instead, we want to delegate the comparison so that we can use the same code, but which can allow for different algorithms to be used, for example...

public class QuickSort {

    public static interface Matcher {

        public int compare(int lhs, int rhs);
    }

    public static void sort(int[] array, Matcher matcher) {

        // An array of size 1 is already sorted                                                                             
        if (array.length < 2) {
            return;
        }

        // Find the largest element and put it at the end of the array                                                      
        int max = 0;
        for (int i = 1; i < array.length; i++) {
            if (matcher.compare(array[i], array[max]) > 0) {
                max = 1;
            }
        }
        swap(array, array.length - 1, max);

        // Call the main quicksort method                                                                                   
        sort(array, 0, array.length - 1, matcher);
    }

    protected static void sort(int[] array, int first, int last, Matcher matcher) {

        int lower = first + 1, upper = last;

        // Use the middle array element as the bound (pivot) and                                                            
        // move it out of the way into the first array element                                                              
        swap(array, first, (first + last) / 2);
        int bound = array[first];

        // Partition the array                                                                                              
        while (lower <= upper) {
            while (matcher.compare(array[lower], bound) < 0) {
                lower++;
            }
            while (matcher.compare(array[upper], bound) > 0) {
                upper--;
            }
            if (lower < upper) {
                swap(array, lower++, upper--);
            } else {
                lower++;
            }
        }

        // Move the pivot into its proper position in the array                                                             
        swap(array, upper, first);

        // Recursively sort the lower and upper subarrays                                                                   
        if (first < upper - 1) {
            sort(array, first, upper - 1, matcher);
        }

        if ((upper + 1) < last) {
            sort(array, upper + 1, last, matcher);
        }
    }

    protected static void swap(int[] values, int first, int second) {
        int temp = values[first];
        values[first] = values[second];
        values[second] = temp;
    }
}

Which can then be used something like...

int[] values = new int[]{1, 0, 2, 9, 3, 8, 4, 7, 5, 6};

QuickSort.sort(values, new QuickSort.Matcher() {
    @Override
    public int compare(int lhs, int rhs) {
        return Integer.compare(lhs, rhs);
    }
});
System.out.println(Arrays.toString(values));

QuickSort.sort(values, new QuickSort.Matcher() {
    @Override
    public int compare(int lhs, int rhs) {
        return Integer.compare(rhs, lhs);
    }
});
System.out.println(Arrays.toString(values));

which will output...

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]