Java 为什么排序/初始化数组不计入大O？

我试图找到问题的最有效答案（不使用哈希映射）：查找数组中最频繁的整数。

我得到的答案是：

public int findPopular(int[] a) {

if (a == null || a.length == 0)
    return 0;

Arrays.sort(a);

int previous = a[0];
int popular = a[0];
int count = 1;
int maxCount = 1;

for (int i = 1; i < a.length; i++) {
    if (a[i] == previous)
        count++;
    else {
        if (count > maxCount) {
            popular = a[i-1];
            maxCount = count;
        }
        previous = a[i];
        count = 1;
    }
}

return count > maxCount ? a[a.length-1] : popular;

}

public int findPopular（int[]a）{
如果（a==null | | a.length==0）
返回0；
数组。排序（a）；
int-previous=a[0]；
int popular=a[0]；
整数计数=1；
int maxCount=1；
for（int i=1；i最大计数）{
流行=a[i-1]；
最大计数=计数；
}
先前=a[i]；
计数=1；
}
}
return count>maxCount？a[a.length-1]：常用；
}

及

公共类模式{
公共静态整数模式（最终整数[]n）{
int maxKey=0；
int maxCounts=0；
int[]计数=新的int[n.长度]；
for（int i=0；i

第一个代码段声明为O（n logn）。但是，Arrays.sort（）函数本身就是O（n logn）[3]。如果添加for循环，findPopular（）函数不是O（n^2*logn）吗？哪个会简化为O（n^2）

第二个代码[2]片段声称是O（n）。然而，为什么我们不考虑数组的初始化到我们的计算中呢？数组的初始化将花费O（n）时间[4]，for循环将花费O（n）。那么mode（）函数不是O（n^2）吗

如果我是正确的，那就意味着我还没有看到比O（n^2）更有效的答案

一如既往，谢谢你的帮助

资料来源：

---

编辑：嗯，我觉得自己像个白痴。我会把这个留在这里，以防有人犯了和我一样的错误

当你一个接一个地执行两项任务时，你会增加复杂性：

Arrays.sort(a); // O(n log n)
for (int i = 0; i < n; i++) { // O(n)
    System.out.println(a[i]);
}
// O(n log n + n) = O(n (log n + 1)) = O(n log n)

Arrays.sort（a）；//O（n日志n）
对于（int i=0；i

仅当您重复一个算法时，您将乘：

for (int i = 0; i < n; i++) { // O(n)
    Arrays.sort(a); // O(n log n), will be executed n times
}
// O((n log n) * n) = O(n² log n)

for（inti=0；i

代码-1：您只有一个for循环。因此，您的时间复杂度将是：

O（n logn）+O（n）

大约等于

（n logn）

代码2：初始化也需要

O（n）

。因此有效地，

O（n）+O（n）（循环）

仍然是

O（n）。

---

注意：在使用O（big-O）计算时间复杂度时，只需使用最大项

Loop O（n）+sort（nlg（n））=O（nlg（n））。感谢您浏览。我不知道我在乘以运算时在想什么。我想我看到了我想看到的。谢谢你。我犯了愚蠢的错误。

for (int i = 0; i < n; i++) { // O(n)
    Arrays.sort(a); // O(n log n), will be executed n times
}
// O((n log n) * n) = O(n² log n)