Java 算法是最优的，它是否满足指定的复杂性？

给定字符串的字符必须按照另一个模式字符串定义的顺序进行排序。复杂性要求O（n+m）其中

n

是字符串长度，

m

是模式长度

例如：

模式：

1234567890aabbccddeffgghh

字符串：

dH7ee2D6a341Fb9Ea20dhC1g7ca32Ba2Gac5f76A2g

结果：

11222223456677790aaaaaaaabbcccdddeeeffggghh

模式具有字符串的所有字符，并且每个字符仅在模式中显示一次

我的代码：

// Instances of possible values ​​for input:
String pattern = "1234567890AaBbCcDdEeFfGgHh";
String string = "dH7ee2D6a341Fb9Ea20dhC1g7ca32Ba2Gac5f76A2g";

// Builder to collect characters for sorted result:
StringBuilder result = new StringBuilder();

// Hash table based on characters from pattern to count occurrence of each character in string:
Map<Character, Integer> characterCount = new LinkedHashMap<>();

for (int i = 0; i < pattern.length(); i++) {
    // Put each character from pattern and initialize its counter with initial value of 0:
    characterCount.put(pattern.charAt(i), 0);
}

// Traverse string and increment counter at each occurrence of character
for (int i = 0; i < string.length(); i++) {
    char ch = string.charAt(i);
    Integer count = characterCount.get(ch);
    characterCount.put(ch, ++count);
}

// Traverse completed dictionary and collect sequentially all characters collected from string
for (Map.Entry<Character, Integer> entry : characterCount.entrySet()) {
    Integer count = entry.getValue();

    if (count > 0) {
        Character ch = entry.getKey();

        // Append each character as many times as it appeared in string
        for (int i = 0; i < count; i++) {
            result.append(ch);
        }
    }
}

// Get final result from builder
return result.toString();

//可能值的实例​​输入：
字符串模式=“1234567890aabbccddeffgghh”；
String String=“dH7ee2D6a341Fb9Ea20dhC1g7ca32Ba2Gac5f76A2g”；
//生成器为排序结果收集字符：
StringBuilder结果=新建StringBuilder（）；
//基于模式中的字符的哈希表，以统计字符串中每个字符的出现次数：
Map characterCount=新建LinkedHashMap（）；
对于（int i=0；i0）{
字符ch=entry.getKey（）；
//附加每个字符的次数与它在字符串中出现的次数相同
for（int i=0；i

---

这个代码是最优的吗？有没有办法改进这个算法？我是否正确理解它满足给定的复杂性O（n+m）？

不确定您或我的计时是否更快。 但这里有一个替代方案：

import java.math.BigDecimal;
class Playground {
    public static void main(String[ ] args) {
        String pattern = "1234567890AaBbCcDdEeFfGgHh";
        String s = "dH7ee2D6a341Fb9Ea20dhC1g7ca32Ba2Gac5f76A2g";
        long startTime = System.nanoTime();
        StringBuilder sb = new StringBuilder();

        for (char c : pattern.toCharArray()) {
            sb.append(s.replaceAll("[^" + c + "]", ""));
        }

        System.out.println(sb.toString());

        BigDecimal  elapsedTime =
            new BigDecimal( String.valueOf(System.nanoTime() - startTime)
                          )
        .divide(
            new BigDecimal( String.valueOf(1_000_000_000)
                          )
        );
        System.out.println(elapsedTime + " seconds");
    }
}

---

说明：

对于模式中的每个字符，使用字符串的基于正则表达式的replaceAll方法将除当前字符外的所有字符替换为空字符串。冲洗并重复。这将使您保留原始中每个字符的完整计数，按模式的字符序列排序

---

产出：

112222233456677790AaaaaaBbCccDddEeeFfGggHh
0.021151652 seconds

---

（时间有点主观。它来自Sololearn Java游乐场。这显然取决于他们服务器上的当前负载）

@Emma I对此也不确定。但我想我会把别的东西扔到罐子里作为替代。我很好奇，看看还有什么其他的东西摆在桌面上。你是在假设Java吗？例如，如果字符存储为可变长度UTF-8，则

charAt（）

将不是O（1），而是O（N）。

append（）

的情况也一样，它可能必须查找数组的结尾。