Question

根据书中 ALGORITHMS 2.2中使用的方法，我在最佳情况下推断了冒泡排序的时间复杂度。但答案结果是O（n ^ 2）。

这是我的推导，希望任何人都可以帮我找出错误的地方：

public void bubbleSort(int arr[]) {
for(int i = 0, len = arr.length; i < len - 1; i++) {
    for(int j = 0; j < len - i - 1; j++) {
        if(arr[j + 1] < arr[j])
            swap(arr, j, j + 1);
    }
}

}

Statements                      cost    times
i = 0,len = arr.length          c1          1
i < len - 1                     c2          n
i++                             c3          n - 1
j = 0                           c4          n - 1
j < len - i - 1                 c5          t1(i=0) + t1(i=1) + ... + t1(i = n-2)
j++                             c6          t2(i=0) + t2(i=1) + ... + t2(i = n-2)
arr[j + 1] < arr[j]             c7          t3(i=0) + t3(i=1) + ... + t3(i = n-2)
swap(arr, j, j + 1)             c8          t4(i=0) + t4(i=1) + ... + t4(i = n-2)

T（n）= c1 + c2n + c3（n - 1）+ c4（n - 1）+ c5t5 + c6t6 + c7t7 + c8t8 = c1 + c2n + c3（n-1）+ c4（n-1）+ c5 [t1（i = 0）+ t1（i = 1）+ ... + t1（i = n-2）] + c6 [t2（i = 0）+ t2（i = 1）+ ... + t2（i = n-2）] + c7 [t3（i = 0）+ t3（i = 1）+ ... + t3 （i = n-2）] + c8 [t4（i = 0）+ t4（i = 1）+ ... + t4（i = n-2）];

在其最佳演员阵容中，序列在排序之前已经是正面的。那么t8应该是0。

T（n）= c1 + c2n + c3（n-1）+ c4（n-1）+ c5 [t1（i = 0）+ t1（i = 1）+ ... + t1（i = n-2）] + c6 [t2（i = 0）+ t2（i = 1）+ ... + t2（i = n-2）] + c7 [t3（i = 0）+ t3（i = 1 ）+ ... + t3（i = n-2）]

时间复杂度为O（n ^ 2）

Answer 1

您的实施

public void bubbleSort(int arr[]) {
    for(int i = 0, len = arr.length; i < len - 1; i++) {
        for(int j = 0; j < len - i - 1; j++) {
            if(arr[j + 1] < arr[j])
                swap(arr, j, j + 1);
        }
    }
}

缺乏控制内循环是否有任何交换，如果没有，则缺少外循环。

该控件使得最佳情况（已经排序的数组）可能是O（n），因为当第一次运行时内部循环中没有交换。

public void bubbleSort(int arr[]) {
    boolean swapped = true;
    for(int i = 0, len = arr.length; swapped && i < len - 1; i++) {
        swapped = false;
        for(int j = 0; j < len - i - 1; j++) {
            if(arr[j + 1] < arr[j]) {
                swap(arr, j, j + 1);
                swapped = true;
            }
        }
    }
}

Answer 2

我不确定你在想什么。通常，当您谈论比较排序算法时，您应该计算所做的比较次数。冒泡排序就是这样的。在这种情况下，您提出的算法是O（n ^ 2）。

如果计算掉期数量，其O（1）或甚至可以说O（0）。然而，很难分析像这样的冒号。

然而，您可以非常轻松地改进Bubble以获得最佳案例的O（N）。例如，引入标志swap_was_made。如果它在内部for结束时是假的，你可以完成。在最好的情况下，它会将复杂度降低到O（N）（一个内部循环）。在公平均匀分布的情况下，它将预期或平均复杂度降低到O（N ^ 2/2）......但请仔细检查我，我可能是错的。这里没做数学。

Answer 3

冒泡排序的最佳情况是元素已经排序。

通常的实现为最佳，平均，最差情况提供O（n ^ 2）时间复杂度。

我们可以通过在每次迭代时检查数组是否已排序（交换将指示未排序的数组）来修改冒泡排序。

一旦发现数组被排序（如果没有发生交换），控制退出循环或循环继续执行直到长度为1。

插入排序也是如此！

为什么泡沫排序的时间复杂度最好的情况是O（n）

3 个答案: