按每个字符的出现次数有效地对字符串进行排序

Question

我正在尝试按每个字符出现的次数对字符串进行排序，最常见的出现在开头，最稀有的出现在结尾。排序后，我需要删除所有重复的字符。因为示例总是更清晰，所以程序应该执行以下操作：

String str = "aebbaaahhhhhhaabbbccdfffeegh";
String output = sortByCharacterOccurrencesAndTrim(str);

在这种情况下，'sortByCharacterOccurrencesAndTrim' 方法应该返回：

String output = "habefcdg"

在 2 个字符出现相同的情况下，它们在返回字符串中的顺序无关紧要。所以“habefcdg”也可以等于“habfecgd”，因为“f”和“e”都出现了3次，而“d”和“g”都出现了一次。

"habefcdg" would effectively be the same as "habfecgd"

注意：我想指出，在这种情况下，性能很重要，所以我希望尽可能采用最有效的方法。我这样说是因为字符串长度可以从 1 到最大长度（我认为与 Integer.MAX_VALUE 相同，但不确定），所以我想尽量减少任何潜在的瓶颈。

Answer 1

只是为了好玩（我并不是说这是最有效的解决方案）：一些 Java 8 lambdas + 并行流怎么样？

public String sortByCharacterOccurrencesAndTrim(String str) {

    // build a frequency map, for each code point store its count    
    Map<Integer, Long> frequencies =
        str.codePoints()
           .parallel()
           .boxed()
           .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

    // sort by descending frequency and collect code points into array
    int[] output =
        frequencies.entrySet()
                   .parallelStream()
                   .sorted(Map.Entry.<Integer, Long>comparingByValue().reversed())
                   .mapToInt(Map.Entry::getKey)
                   .toArray();

    // create output string from code point array
    return new String(output, 0, output.length);

}

如果您想要一个超高效的解决方案，您可以使用显式循环重写上述算法，但这是很多代码，对我来说已经晚了:)。然而，想法是一样的：构建一个 char 频率图，使用降序按频率排序，然后用 char 构建一个字符串。

Answer 2

注意：这不是答案，只是显示Jim Mischel 和Óscar López 答案的性能测试代码（响应comment by OP 的并行流）。

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String s = buildString();
        System.out.println("buildString: " + (System.currentTimeMillis() - start) + "ms");

        start = System.currentTimeMillis();
        String result1 = testUsingArray(s);
        System.out.println("testUsingArray: " + (System.currentTimeMillis() - start) + "ms");

        start = System.currentTimeMillis();
        String result2 = testUsingMap(s);
        System.out.println("testUsingMap: " + (System.currentTimeMillis() - start) + "ms");

        start = System.currentTimeMillis();
        String result3 = testUsingStream(s);
        System.out.println("testUsingStream: " + (System.currentTimeMillis() - start) + "ms");

        start = System.currentTimeMillis();
        String result4 = testUsingParallelStream(s);
        System.out.println("testUsingParallelStream: " + (System.currentTimeMillis() - start) + "ms");

        System.out.println(result1);
        System.out.println(result2);
        System.out.println(result3);
        System.out.println(result4);
    }
    private static String buildString() {
        Random rnd = new Random();
        char[] buf = new char[100_000_000];
        for (int i = 0; i < buf.length; i++)
            buf[i] = (char)(rnd.nextInt(127 - 33) + 33);
        return new String(buf);
    }
    private static String testUsingArray(String s) {
        int[] count = new int[65536];
        for (int i = 0; i < s.length(); i++)
            count[s.charAt(i)]++;
        List<CharCount> list = new ArrayList<>();
        for (int i = 0; i < 65536; i++)
            if (count[i] != 0)
                list.add(new CharCount((char)i, count[i]));
        Collections.sort(list);
        char[] buf = new char[list.size()];
        for (int i = 0; i < buf.length; i++)
            buf[i] = list.get(i).ch;
        return new String(buf);
    }
    private static String testUsingMap(String s) {
        Map<Character, CharCount> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++)
            map.computeIfAbsent(s.charAt(i), CharCount::new).count++;
        List<CharCount> list = new ArrayList<>(map.values());
        Collections.sort(list);
        char[] buf = new char[list.size()];
        for (int i = 0; i < buf.length; i++)
            buf[i] = list.get(i).ch;
        return new String(buf);
    }
    private static String testUsingStream(String s) {
        int[] output = s.codePoints()
                        .boxed()
                        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
                        .entrySet()
                        .stream()
                        .sorted(Map.Entry.<Integer, Long>comparingByValue().reversed())
                        .mapToInt(Map.Entry::getKey)
                        .toArray();
        return new String(output, 0, output.length);
    }
    private static String testUsingParallelStream(String s) {
        int[] output = s.codePoints()
                        .parallel()
                        .boxed()
                        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
                        .entrySet()
                        .parallelStream()
                        .sorted(Map.Entry.<Integer, Long>comparingByValue().reversed())
                        .mapToInt(Map.Entry::getKey)
                        .toArray();
        return new String(output, 0, output.length);
    }
}
class CharCount implements Comparable<CharCount> {
    final char ch;
    int count;
    CharCount(char ch) {
        this.ch = ch;
    }
    CharCount(char ch, int count) {
        this.ch = ch;
        this.count = count;
    }
    @Override
    public int compareTo(CharCount that) {
        return Integer.compare(that.count, this.count); // descending
    }
}

样本输出

buildString: 974ms
testUsingArray: 48ms
testUsingMap: 216ms
testUsingStream: 1279ms
testUsingParallelStream: 442ms
UOMP<FV{KHt`(-q6;Gl'R9nxy+.Y[=2a7^45v?E@e,>|AD_\ILpJ}8sow"Z&bCmNW1$!Sd0c]~g3BjX#fz:Q*Tkui%/r)h
UOMP<FV{KHt`(-q6;Gl'R9nxy+.Y[=2a7^45v?E@e,>|AD_\ILpJ}8sow"Z&bCmNW1$!Sd0c]~g3BjX#fz:Q*Tkui%/r)h
UOMP<FV{KHt`(-q6;Gl'R9nxy+.Y[=2a7^45v?E@e,>|AD_\ILpJ}8sow"Z&bCmNW1$!Sd0c]~g3BjX#fz:Q*Tkui%/r)h
UOMP<FV{KHt`(-q6;Gl'R9nxy+.Y[=2a7^45v?E@e,>|AD_\ILpJ}8sow"Z&bCmNW1$!Sd0c]~g3BjX#fz:Q*Tkui%/r)h

Answer 3

我对流和 lambdas 一无所知，但我会做这样的事情：

Map<Character, Integer> map;
for (int i=0;i<str.length,i++){
    char c = s.charAt(i);
    switch(c){
        case: map.containsKey(c):
            int temp = map.get(c)++;
            map.put(c, tmp);
            break;
        case: !map.containsKey(c):
            map.put(c, tmp);
            break;
    }
}        

计算出现次数。然后就是事后从高到低排序。

Answer 4

“一个地图和几个while循环”当然是最简单的方法，而且可能会非常快。这个想法是：

for each character
    increment its count in the map
Sort the map in descending order
Output the map keys in that order

但是 100,000,000 次地图查找可能会变得非常昂贵。您可以通过创建一个包含 65,536 个整数计数（如果是 ASCII 则为 128 个字符）的数组来潜在地加速它。那么：

for each character
    array[(int)ch] += 1

然后，您遍历该数组并创建具有非零计数的字符映射：

for i = 0 to 65535
    if array[i] > 0
        map.add((char)i, array[i])

然后按降序对地图进行排序，并按该顺序输出字符。

这可能会执行得更快一些，因为索引到数组 100,000,000 次可能比执行 100,000,000 次地图查找要快得多。