这种排序算法的大 O [重复]答案

【问题标题】：Big O of this sorting algorithm [duplicate]这种排序算法的大 O [重复]
【发布时间】：2013-01-23 16:32:29
【问题描述】：

可能重复：
What’s the complexity of for i: for o = i+1

我对长度为 5 的数组做了以下排序算法：

int myarray[5] = {2,4,3,5,1};
    int i;
    for (i = 0; i < 5; i++)
    {
        printf("%d", myarray[i]);

        int j;
        for (j=i+1; j < 5; j++) 
        {
            int tmp = myarray[i];
            if (myarray[i] > myarray[j]) {
                tmp = myarray[i];
                myarray[i] = myarray[j];
                myarray[j] = tmp;
            }
        }
    }

我相信这种排序算法的复杂性是O(n*n)，因为对于每个元素，您都将它与其他元素进行比较。但是，我也注意到，每次我们在外循环中创建时，我们都不会与所有其余部分进行比较，而是与其余部分进行比较 - i。复杂度是多少？

【问题讨论】：

另见this

标签： c arrays complexity-theory

【解决方案1】：

它仍然是O(n²)（或O(n * n)，如您所写）。在分析计算复杂度时，只有最高阶项很重要。

【讨论】：

【解决方案2】：

你是对的：
这是 O(1 + 2 + 3... + N)
但从数学上讲，它只是：
= O(n*((n-1)/2))
但这只是：
= O(n^2)

【讨论】：

【解决方案3】：

你是对的，它是 O(n²)。

这是计算方法。在第一次迭代中，您将查看 n 个元素；接下来，n - 1，依此类推。如果您将该总和的两个副本除以二，您可以将这些术语配对，这样您将第一个副本 n 中的第一个术语添加到第二个副本 1 的最后一个术语中，等等。你得到 n + 1 的 n 个副本，所以总和是 n * (n + 1) / 2. Big-O 只区分渐近行为；渐近行为由最高阶项描述，不考虑常数因子，即 n²。

n + (n - 1) + (n - 2) ... + 1
= 2 * (n + (n - 1) + (n - 2) ... + 1) / 2
= ((n + 1) + (n - 1 + 2) + (n - 2 + 3) + ... + ( 1 + n)) / 2
= ((n + 1) + (n + 1) + ... + (n + 1)) / 2
= n * (n + 1) / 2
= 1/2 * n² + 1/2 * n
= O(n²)

【讨论】：

【解决方案4】：

这是冒泡排序，复杂度确实是O(n^2)

算法的整个运行时间可以概括为以下总和：

n + (n-1) + (n-2) + ... + 1 = n(n+1)/2

由于在渐近分析中只对最高阶项感兴趣，因此复杂度为 O(n^2)

【讨论】：

【解决方案5】：

大 O 表示法是渐近的。这意味着我们忽略了诸如- i 之类的常数因素。你的算法的复杂度是O(N²)（另见here）。

【讨论】：

【解决方案6】：

复杂度为O(1)。 O 表示法仅对大型输入有意义，其中增加或减少不仅可见，而且相关。

如果你要扩展它，它会是O(n^2)，是的。

【讨论】：

【解决方案7】：

用于多个循环

n*m*..no.of 循环

上面的代码在最坏的情况下它的 n*n=n^2

BigOh 表示最大界限。

所以最大复杂度不能大于这个。

【讨论】：

不仅在最坏的情况下，而且在任何情况下......
同意你的看法。但是 bigoh 意味着最大界限，所以它是最坏的情况:)。

【解决方案8】：

对于 i=0 运行 n 次

i=1 运行 n-1 次

i=2 它运行 n-2 次 ....

  So total Sum = (n) + (n-1) + (n-2) + .... + 1
           sum =  (n*n) - (1 + 2 + ...)
               =  n^2   -

如此大的 O 复杂度 = O(n^2) { 上限； + 或 - 被忽略 }

【讨论】：