Time complexity 求堆函数的复杂性

我将使用以下代码进行堆排序（链接：）

给定以下代码：

public static void sort(Comparable[] pq) {                     // Complexity: O(NLog N)
    int n = pq.length;                                         // Complexity: O(1)
    for (int k = n/2; k >= 1; k--)                             // Complexity: O(N)
        sink(pq, k, n);                                        // Complexity: O(Log N)
    while (n > 1) {                                            // Complexity: O(N)
        exch(pq, 1, n--);                                      // Complexity: O(1)
        sink(pq, 1, n);                                        // Complexity: O(Log N)
    }
}

private static void sink(Comparable[] pq, int k, int n) {      // Complexity: O(Log N)
    while (2*k <= n) {                                         // Complexity: O(Log N)
        int j = 2*k;                                           // Complexity: O(1)
        if (j < n && less(pq, j, j+1)) j++;                    // Complexity: O(1)
        if (!less(pq, k, j)) break;                            // Complexity: O(1)
        exch(pq, k, j);                                        // Complexity: O(1)
        k = j;                                                 // Complexity: O(1)
    }
}
private static boolean less(Comparable[] pq, int i, int j) {   // Complexity: O(1)
    return pq[i-1].compareTo(pq[j-1]) < 0;                     // Complexity: O(1)
}
private static void exch(Object[] pq, int i, int j) {          // Complexity: O(1)
    Object swap = pq[i-1];                                     // Complexity: O(1)
    pq[i-1] = pq[j-1];                                         // Complexity: O(1)
    pq[j-1] = swap;                                            // Complexity: O(1)
}

publicstaticvoidsort（可比较的[]pq）{//复杂性：O（nlogn）
int n=pq.length；//复杂性：O（1）
for（intk=n/2；k>=1；k--）//复杂性：O（n）
sink（pq，k，n）；//复杂性：O（logn）
而（n>1）{//复杂性：O（n）
exch（pq，1，n--）；//复杂性：O（1）
sink（pq，1，n）；//复杂性：O（logn）
}
}
私有静态无效接收器（可比较的[]pq，int k，int n）{//复杂性：O（Log n）
而（2*k您的逻辑看起来是正确的。排序函数是N+Nlog（N），它确实简化为Nlog（N）。通常情况下，您不会逐行进行此类分析，而是只查找代码中涉及迭代的每个位置，但这种方法是有效的。
请注意
sink
的复杂性：它也取决于
k
的值，并且应写成
O（log N-log k）
。好的..看起来不错，那么我们是否总是只关注影响大部分复杂性的循环？基本上是的。