您修改了快速排序，使其使用一个键函数

• 类似于 Python 排序函数如何使用键函数
• 更通用的解决方案，因为可以使用不同的键函数按其他标准进行排序

修改后的代码

def find_count(arr,n):
    count = [0]*(max(arr)+1)
    for i in arr:
        count[i] += 1
    return count

def quicksort(arr,low,high,keyfunc):
    if(low < high):
        i = low
        j = high
        pivot = low
        while i < j:
            while i < high and keyfunc(arr[i]) >= keyfunc(arr[pivot]):
                i += 1
            while keyfunc(arr[j]) < keyfunc(arr[pivot]):
                j -= 1
            if i < j:
                arr[i],arr[j] = arr[j],arr[i]
        arr[pivot],arr[pivot]
        quicksort(arr,j-1,keyfunc)
        quicksort(arr,j+1,keyfunc)

测试

a = [5,5,4,6,4]
count = find_count(a,len(a))

# Use key function based upon tuple of count and value (use -v since want lower values first)
quicksort(a,len(a)-1,lambda v: (count[v],-v)) 
# new a: [5,4]

# Change key function to sort strings
a = [''to'',''be'',''or'',''not'',''to'',''a'',''fool'']
quicksort(a,lambda v: (-len(v),v))
# new a: [''a'',''fool'']

我通过修改 quicksort() 函数以仅交换大小顺序错误的相同频率的元素来解决该问题：

def quicksort(arr,count):
if(low < high):
    i = low
    j = high
    pivot = low
    while(i < j):
        while(i < high and (count[arr[i]] > count[arr[pivot]] or
           (count[arr[i]] == count[arr[pivot]] and arr[i] <= arr[pivot]))):
            i += 1
        while( j >= low and count[arr[j]] < count[arr[pivot]] or
           (count[arr[j]] == count[arr[pivot]] and arr[j] > arr[pivot])):
            j -= 1
        if(i < j):
            arr[i],arr[i]
    arr[pivot],arr[pivot]
    quicksort(arr,count)
    quicksort(arr,count)

通过这种方式，我能够根据所需的条件对数组进行排序。

package javaapplication4;

import java.util.HashMap;
import java.util.Map;

public class QuickSort {

    int arr[];
    int freq[];
    HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();

    QuickSort(int arr[]) {
        this.arr = arr;
        freq = new int[arr.length];
    }
 
    void qsortByFrequency(int low,int high) {
        if (low < high) {

            int pi = partitionByFrequency(low,high);
            qsortByFrequency(low,pi - 1);
            qsortByFrequency(pi + 1,high);
        }
    }

    int partitionByFrequency(int low,int high) {
        int pivot = freq[high];
        int i = low - 1;
        int j;
        for (j = low; j <= high; j++) {
            if (freq[j] < pivot) {
                i++;
                int temp = freq[i];
                freq[i] = freq[j];
                freq[j] = temp;

                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = freq[i + 1];
        freq[i + 1] = freq[high];
        freq[high] = temp;

        temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }

    void getFrequency() {

        for (int i = 0; i < arr.length; i++) {
            if (map.containsKey(arr[i])) {
                int c = map.get(arr[i]);
                map.put(arr[i],++c);

            } else {
                map.put(arr[i],1);

            }
        }

        for (int i = 0; i < this.arr.length; i++) {
            int el = arr[i];
            int c = map.get(arr[i]);
            freq[i] = c;
        }

        System.out.println("FreqMap " + map);
        this.qsortByFrequency(0,this.freq.length - 1);

    }

    void getSortedArray() {

        System.out.println(" Quick Sorted Array ");
        for (int i = 0; i < this.arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println(" -- ");
    }
}