Question

有谁知道如何对字符串进行排序，例如：afacfa进入aaaffc？（频率降序）我对编程很陌生，只能想出来。

String word = (String)jTextField1.getText();
        String indexes = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        int[] count = new int[indexes.length()];
        for (int i = 0; i < word.length(); i++) {
            int index = indexes.indexOf(word.charAt(i));

        System.out.println( "" + i + count[2] ) ;
        if (index < 0)
        continue;

    count[index]++;
        }
        for (int i = 0; i < count.length; i++) {
    if (count[i] < 1)
        continue;

    jTextArea1.append(String.format("%s (%d) %s",indexes.charAt(i),count[i],

            new String(new char[count[i]]).replace('\0', '*')));

Answer 1

你的算法也不错，你可以通过使用字符的ASCII值直接查找数组并保存indexOf步骤来加快速度。

即。对于大写字符，c-'A'是0到26之间的数字。

如果你的程序遇到任何不在映射数组中的字符，那么你的程序就会崩溃。

要解决此问题，您可以考虑使用Map char Integer来存储计数，并在计数值为1时向地图键添加字符它们，如果已经存在，则将计数递增1。

Answer 2

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MyPrg {
    public static void main(String[] args) {
        String name = "afacfa";

        System.out.println("Input Text = " + name);
        System.out.println("Result = " + arrangeCharactersInIncreasingOrderOfFrequency(name));

    }

    public static String arrangeCharactersInIncreasingOrderOfFrequency(String inputString) {
        String result = "";
        List<String> updatedStringList = new ArrayList<String>();

        for (int i = 0; i < inputString.length(); i++) {
            updatedStringList.add(inputString.substring(i, i + 1));
        }
        Collections.sort(updatedStringList);

        for (String abc : updatedStringList) {
            result = result.concat(abc);
        }
        return result;
    }
}

Answer 3

如果您熟悉哈希映射，则此代码可以轻松地执行您想要的操作。 hashmap值是频率计数器，它通过查找hashmap内的最大值来打印输出。

import java.util.Arrays;
import java.util.HashMap;

public class FrequencyPrint {
    public static void main(String[] args) {
        String s = "ccrrcdcffcghijk";
        HashMap<Character, Integer> hashMap = new HashMap<Character, Integer>();
        for (int i = 0; i < s.length(); i++) {
            if (hashMap.containsKey(s.charAt(i))) {
                int value = hashMap.get(s.charAt(i));
                hashMap.put(s.charAt(i), ++value);
            } else {
                hashMap.put(s.charAt(i), 1);
            }
        }

        Character keys[] = Arrays.copyOf(hashMap.keySet().toArray(), hashMap
                .keySet().toArray().length, Character[].class);
        Integer values[] = Arrays.copyOf(hashMap.values().toArray(), hashMap
                .values().toArray().length, Integer[].class);


        for (int i = 0; i < keys.length; i++) {
            int x = FrequencyPrint.findmax(values);
            for (int j = 0; j < values[x]; j++) {
                System.out.print(keys[x]);
            }
            values[x] = 0;
        }

    }

    public static int findmax(Integer values[]) {
        int max = 0;
        for (int i = 0; i < values.length; i++) {
            if (values[i] > values[max]) {
                max = i;
            }
        }
        return max;
    }
}

字符串按降序排序

3 个答案: