Question

所以基本上我试图理解如何计算Bitonic Sort的时间复杂度，并使用Cost和Time决定最佳和最差情况，然后再加上和乘以值。

作为一个例子：我首先尝试计算插入排序的复杂性。

        void sort(int A[]){                             Cost        Time

        for (int i = 1; i < A.length; i++)              c1          n
        {
            int key = A[i];                             c2          n-1
            int j = i-1;                                c3          n-1
            while (j >= 0 && A[j] > key){               c4          Σ (j=2 to n) of t_j
                A[j+1] = A[j];                          c5          Σ (j=2 to n) of (t_j-1)
                j = j-1;                                c6          Σ (j=2 to n) of (t_j-1)
            }
            A[j+1] = key;                               c7          n-1
        }
    }

t_j - 执行“while”周期的次数。

T（n）= c1 * n + c2（n-1）+ c3（n-1）+ c4（t_j的Σ（j = 2到n））+

+ c5（（t_j-1））的Σ（j = 2到n）+ c6（（t_j-1））Σ（j = 2到n）+ c7（n-1）

所以在最好的情况下，t_j = 1，那么：T（n）= an + b; （a，b - 常数）

在最坏的情况下，t_j = j，则：T（n）= an ^ 2 + bn + c;

所以 - O（n） - 最好的情况？ O（n ^ 2） - 更糟糕的情况？

但是我真的不明白比特式排序方法的操作成本和时间应该是多少，例如像这样的代码：

   public class BitonicSorter implements Sorter
{
    private int[] a;
    private final static boolean ASCENDING=true, DESCENDING=false;

    public void sort(int[] a)
    {
        this.a=a;
        bitonicSort(0, a.length, ASCENDING);
    }

    private void bitonicSort(int lo, int n, boolean dir)
    {
        if (n>1)
        {
            int m=n/2;
            bitonicSort(lo, m, ASCENDING);
            bitonicSort(lo+m, m, DESCENDING);
            bitonicMerge(lo, n, dir);
        }
    }

    private void bitonicMerge(int lo, int n, boolean dir)
    {
        if (n>1)
        {
            int m=n/2;
            for (int i=lo; i<lo+m; i++)
                compare(i, i+m, dir);
            bitonicMerge(lo, m, dir);
            bitonicMerge(lo+m, m, dir);
        }
    }

    private void compare(int i, int j, boolean dir)
    {
        if (dir==(a[i]>a[j]))
            exchange(i, j);
    }

    private void exchange(int i, int j)
    {
        int t=a[i];
        a[i]=a[j];
        a[j]=t;
    }

}

也许有人曾尝试计算此Sort算法的复杂性，并且可以举例说明成本和时间？或者参考了解应该归因于哪些成本和时间？

P.S我是新手，并没有正确理解它应该如何“计算”，所以请随意提出建议。升值。

Answer 1

要分析递归过程，您需要编写并解决重复过程。在这里，让S(n)为排序n元素的比较次数，M(n)为合并n元素的比较次数。

           S(1) = 0
for n > 1, S(n) = 2 S(n/2) + M(n)
           M(1) = 0
for n > 1, M(n) = 2 M(n/2) + n/2

我们可以使用Master Theorem的案例2来解决这些问题。

M(n) = Theta(n log n)
S(n) = 2 S(n/2) + Theta(n log n) = Theta(n (log n)^2)

Answer 2

@ DavidEisenstat的answer是正确的，但是 - 为了让事情更简单，假设我们更换了：

private void compare(int i, int j, boolean dir)
{
    if (dir==(a[i]>a[j]))
        exchange(i, j);
}

代码中的

private void compare(int i, int j, boolean dir)
{
     a[i] = (a[i]>a[j]) ? a[j] : a[i];
     a[j] = (a[i]>a[j]) ? a[i] : a[j];
}

现在整个程序绝对没有分支;它完全是非自适应的，最好和最坏的情况都是一样的。（好吧，基本上;我忽略了CPU分支预测之类的东西等等）。这是bitonic排序的一个很好的特性，这使得它对硬件实现很有吸引力 - 并且它使最坏情况更容易分析。

Bitonic Sort（计算复杂度）

2 个答案: