Java检查该字符串是否是另一个字符串O（log n）的字谜

所以我最近一直在研究算法的运行时复杂性，想知道当n的规模增加时，如何改变它们以提高效率，所以我的目标基本上是学习如何使事情变成O（logn）。我想，我知道这个小时我可以做一个很好的小项目，那就是创建一个字谜检查器

我翻阅了几篇SO帖子，看到有人评论说，如果将字母表中的每个字母都指定为数字，则可以将其设置为log n，因此：

final Map<Character, Integer> map;
        String str = "hello";
        String check = "olleh";

        map = new HashMap<>();
        map.put('a', 2);
        map.put('b', 3);
        map.put('c', 4);
        map.put('d', 7);
        map.put('e', 11);
        map.put('f', 13);
        map.put('g', 17);
        map.put('h', 19);
        map.put('i', 23);
        map.put('j', 29);
        map.put('k', 31);
        map.put('l', 37);
        map.put('m', 41);
        map.put('n', 43);
        map.put('o', 47);
        map.put('p', 53);
        map.put('q', 59);
        map.put('r', 61);
        map.put('s', 67);
        map.put('t', 71);
        map.put('u', 73);
        map.put('v', 79);
        map.put('w', 83);
        map.put('x', 89);
        map.put('y', 97);
        map.put('z', 101);

最终地图；
String str=“hello”；
字符串检查=“olleh”；
map=新的HashMap（）；
地图放置（'a'，2）；
地图放置（'b'，3）；
地图放置（'c'，4）；
地图放置（'d'，7）；
地图放置（'e'，11）；
地图放置（'f'，13）；
地图放置（'g'，17）；
地图放置（'h'，19）；
地图放置（'i'，23）；
地图放置（'j'，29）；
地图放置（'k'，31）；
地图放置（'l'，37）；
地图放置（'m'，41）；
地图编号（'n'，43）；
地图放置（'o'，47）；
地图放置（'p'，53）；
地图放置（'q'，59）；
地图放置（'r'，61）；
地图.put（'s'，67）；
地图放置（'t'，71）；
地图放置（'u'，73）；
地图放置（'v'，79）；
地图放置（'w'，83）；
地图放置（'x'，89）；
地图放置（'y'，97）；
地图放置（'z'，101）；

然后我创建了这个方法：

 public static boolean isAnagram(String s, String check,Map<Character, Integer> map) {
        int stringTotal = 0;
        int checkTotal = 0;
        for(char ch: s.toCharArray()){
            int i = map.get(ch);
            stringTotal += ch;
        }
        for(char ch: check.toCharArray()){
            int i = map.get(ch);
            checkTotal +=ch;
        }
        if (stringTotal == checkTotal){
            return true;
        }
        return false;
    }

publicstaticbooleanisangram（字符串s、字符串检查、映射）{
int-stringTotal=0；
int checkTotal=0；
for（char ch:s.toCharArray（））{
int i=map.get（ch）；
stringTotal+=ch；
}
for（char ch:check.toCharArray（））{
int i=map.get（ch）；
checkTotal+=ch；
}
如果（stringTotal==checkTotal）{
返回true；
}
返回false；
}

我相信这个方法是O（n^2），因为它有两个独立的循环，我想不出创建O（logn）方法背后的逻辑

任何指针都很好

它看起来是

O（2n）

：一个又一个

n

循环。如果将

n

的循环嵌套在

n

的循环中，则会得到

O（n^2）

， 像这样：

这里，

count

是

n+n

或2n

无法使用此函数生成

O（logn）

函数，因为您将始终需要检查所有

n

值（所有字母）

---

例如，假设我们计算出函数的精确值为

log（n）

（注意，这不同于去掉系数和低阶项的顺序

O（logn）

）
现在，如果

n=10

；然后

log（n）=2.3

（大约），如果你只看2.3个字母，你不能确定一个10个字母的单词是另一个10个字母单词的拼字法。

我会去掉最后一句，从“例如”开始。如果算法具有时间复杂度

O（logn）

，则可能存在一个较大的比例常数。这并不意味着它读的是

2.3

个字符。我不懂。。对于复杂度

O（logn）

的算法，其中

n=10

，它确实意味着算法检查

log（10）

或

2.3

字符。这是一个例子。对于

n=1000

，

logn

约为6.9，因此我看不到任何比例常数。你能澄清一下吗？

O（logn）

是指当n越来越大时所需的时间，因此一个特定值

n

的单独示例永远无法证明它有或没有特定的时间复杂性。如果可以证明一个算法需要精确的

Math.floor（1000000*log（n））

步骤，那么时间复杂度将是

O（log n）

，因为您可以忽略像

1000000

这样的大因素。因此，您不能通过检查2.3个字符来读取长度为10的字符串这一事实并不真正相关。感谢您的回答和评论，那么这种情况下最有效的算法是O（n log n）？@user3667111不，您可以在

O（n）

中执行。使用两个

HashMap

计算出现次数，然后检查映射是否相等。仅供参考，两个独立循环并不意味着O（N^2）。想想看。。。您将遍历长度为N的数组两次（2N）。预先快速检查以确保您不会花费时间在昂贵的ish操作中，即确保字符串的长度在逻辑之前相等。哦，是的，当然@Tgsmith61591感谢您指出这一点，请检查此解决方案

int count = 0;
for ( int x = 0; x < n; x++ )
     for ( int y = 0; y < n; y++ )
         count++;

int count = 0;
for ( int x = 0; x < n; x++ )
    count++;
for ( int y = 0; y < n; y++ )
    count++;