如何计算冒泡排序时间复杂度答案

【问题标题】：how to calculate Bubble sort Time Complexity如何计算冒泡排序时间复杂度
【发布时间】：2015-06-15 20:13:07
【问题描述】：

我试图了解数据结构和不同的算法，然后我对测量冒泡排序时间复杂度感到困惑。

for (c = 0; c < ( n - 1 ); c++) {
  for (d = 0; d < n - c - 1; d++) {
    if (array[d] > array[d+1]) /* For descending order use < */
    {
      swap       = array[d];
      array[d]   = array[d+1];
      array[d+1] = swap;
    }
  }
}

现在每个大 O 都告诉最佳情况 O(n)、平均情况 (n2) 和最坏情况 (n2)。但是当我看到代码时，发现在第一阶段内循环运行 n 次，然后在第二阶段 n - 1 , 和 n - 2 等等。这意味着在每次迭代中，它的价值都会下降。例如，如果我有 a[] = {4, 2, 9, 5, 3, 6, 11} 那么比较的总数将是 -

1st Phase - 7 time
2nd phase - 6 time
3rd Phase - 5 time
4th Phase - 4 time
5th Phase - 3 time
6th Phase - 2 time
7th Phase - 1 time

所以当我计算时间时，它看起来像 = (7 + 6 + 5 + 4 + 3 + 2 + 1) + 7 = 35，但根据文档，最差的时间复杂度是 n2。

所以有人可以告诉我如何计算正确的值。

【问题讨论】：

O(n^2) 非常不意味着总步数将完全等于n^2。
要添加到@AakashM，首先需要了解O(...)符号的含义。例如：stackoverflow.com/questions/487258/…

标签： algorithm sorting

【解决方案1】：

所以您已经注意到完成的比较总数是 (n - 1) + ... + 2 + 1。这个总和等于 n * (n - 1) / 2（参见Triangular Numbers），等于 0.5 n^2 - 0.5 n，显然是 O(n^2)。

【讨论】：

【解决方案2】：

让我们来看看大 O 冒泡排序的案例

案例 1) O(n) （最佳情况）如果数组已经排序，则可能会出现这种时间复杂度，这意味着没有发生交换并且只有 n 个元素的 1 次迭代

情况 2) O(n^2) （最坏情况）最坏的情况是如果数组已经排序但按降序排列。这意味着在第一次迭代中它必须查看 n 个元素，然后它会查看 n - 1 个元素（因为最大的整数在末尾）等等，直到发生 1 个比较。大O = n + n - 1 + n - 2 ... + 1 = (n*(n + 1))/2 = O(n^2)

在您的示例中，它可能不会检查每个阶段中的这么多元素，因为数组不是按降序排列的。

【讨论】：

作为定义，Big Oh (O) 表示法仅表示最坏情况，而 Big Omega Ω(O) 表示法表示最佳情况！
BubbleSort 的 O(n) 变体是在没有其他东西可排序时停止迭代的变体。这个问题中的代码总是运行大约内部循环。 n^2/2 次，甚至认为它并不总是交换。所以这段代码对于所有输入都是 O(n^2)。
此外，Big-O 与最佳/最坏情况无关。 Big-O 的意思是“上限”。 Omega的意思是“下限”。说 BubbleSort 对于所有输入都是 Ω(n) 和 O(n^2) 是有道理的，但是说在最好的情况下它是 O(n) 甚至是 Ω(n^2) 也是有道理的在最坏的情况下。

【解决方案3】：

它在两个元素之间进行比较。所以在第一阶段 - n-1 比较。即 6 第二阶段 - n-2 比较。即 5 依此类推，直到 1。因此， sum = n(n-1)/2 即 O(n^2)。

如果有任何错误你可以纠正.....

【讨论】：

【解决方案4】：

在这里解释最坏的情况：

elements = raw_input("enter comma separated elements : ")
elements = elements.split(',')
elements = map(int, elements)
length = len(elements)

for i in xrange(length - 1):
    print "outer pass : ", i
   for j in xrange(length - i - 1):
       print "inner pass : ", j
       if elements[j] > elements[j + 1]:
           elements[j + 1], elements[j] = elements[j], elements[j + 1]
       print "elements : ", elements
print elements

输出：

输入逗号分隔的元素：5,4,3,2,1

外传：0

内传：0

元素：[4, 5, 3, 2, 1]

内传：1

元素：[4, 3, 5, 2, 1]

内传：2

元素：[4, 3, 2, 5, 1]

内传：3

元素：[4, 3, 2, 1, 5]

外传：1

内传：0

元素：[3, 4, 2, 1, 5]

内传：1

元素：[3, 2, 4, 1, 5]

内传：2

元素：[3, 2, 1, 4, 5]

外传：2

内传：0

元素：[2, 3, 1, 4, 5]

内传：1

元素：[2, 1, 3, 4, 5]

外传：3

内传：0

元素：[1, 2, 3, 4, 5]

[1, 2, 3, 4, 5]

因此第一次迭代扫描所有n个元素，它将在下一次迭代中扫描n-1个元素。以此类推所有元素。

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

【讨论】：

【解决方案5】：

O(n^2) = n(n-1)/2 是正确的。

如上例中的 5 个元素。

5(5-1)/2 == 10.

5(5+1)/2 != 10.

【讨论】：

【解决方案6】：

对于 n 个数字，完成的比较总数将是 (n - 1) + ... + 2 + 1。这个和等于 (n-1) * n / 2（请参阅三角数）等于 0.5 n^2 - 0.5 n 即 O(n^2)

【讨论】：

【解决方案7】：

最佳情况：如果数组已经排序，则可能会出现这种时间复杂度。这意味着不会发生交换，并且只会有 n 个元素的 1 次迭代。

所以时间复杂度是O(n)。

最坏情况：如果数组已经排序但降序排列，则可能会出现这种时间复杂度。

在 1st 迭代中，比较次数 = n-1
在 2nd 迭代中，比较次数 = n-2
....... ..................................................... ..
.................................................. ..................................
....... ..................................................... .....
在 (n-2)th 次迭代中，比较次数 = 2
在 (n-1)th 次迭代中，比较次数 = 1

对于n个元素的总迭代次数= n-1
比较总数S = (n-1)+ (n-2) +........ + 2    +    1
我们也可以这样写         S =      1 +      2 + ........+(n-2) + (n-1)
..................................................... ..................................................... ...................... 2S =      n +    n + ......... +   n +    n .... [添加两行]
2S = n(n-1) ..... [作为迭代总数 = n-1]
S = n(n-1)/2
在多项式函数中，n的最高阶被认为是时间复杂度。
所以，时间复杂度是 O(n^2)

【讨论】：