Question

我正在尝试找到用于stooge排序的Big O.来自维基百科

algorithm stoogesort(array L, i = 0, j = length(L)-1)
     if L[j] < L[i] then
         L[i] ↔ L[j]
     if j - i > 1 then
         t = (j - i + 1)/3
         stoogesort(L, i  , j-t)
         stoogesort(L, i+t, j  )
         stoogesort(L, i  , j-t)
     return L

我在性能分析方面表现不佳......我画了递归树

我相信......：

身高：log(n)
在0级工作：n //我是从0级还是1级开始？
在第1级工作：2n
工作于第2级：4n
在3级工作：8n
在级别log（n）上工作：(2^log(n))n = O(n^2)？ 2^log2(n) = n，但2^log3(n)实际给出了什么？

那么O(n^2 * log(n)) = O(n^2)？它远离维基百科的O(n^(log3/log1.5)) ...

Answer 1

k级问题的大小为（2/3）^k n。最低级别的大小为1，因此设置（2/3）^k n = 1，深度为k = log _1.5 n（将两边除以（2） / 3）^k，取记录基数1.5）。

级别k的调用次数为3 ^k。在级别k = log _1.5 n时，这是3 ^{log _1.5 n} =（（1.5）^{log _1.5 3}）^{log _1.5 n} =（（1.5）^{log _1.5 n}）^{log _1.5 3} = n ^{log _1.5 3} = n ^{log 3 / log 1.5}。< / p>

由于每个级别的工作几何增加，叶子上的工作占主导地位。

Answer 2

您可以使用Master Theorem查找此答案。我们可以从算法中看出递归关系是：

T（n）= 3 * T（2/3 n）+ 1

应用定理：

f（n）= 1 = O（n ^c），其中c = 0。 a = 3，b = 3/2 =＆gt; log3 / 2（3）= ~2.70

因为c < log3 / 2（3），我们在定理的案例1中，所以：

T（n）= O（n ^{log3 / 2（3）}）= O（n ^2.70）

Answer 3

如果我们将T（n）定义为答案（j-i + 1 = n），我们有：
T（n）= 3 * T（n / 1.5）+ O（1）

你可以使用Master Theorem解决这个问题，答案是theta（n ^ log（3,1.5））= theta（n ^（log 3 / log 1.5））

你也可以证明在n上使用感应。

使用递归树也是可以接受的：
k =等级数= log（n，1.5）
ans = 1 + 3 + 3 ^ 2 + ... + 3 ^ k = theta（3 ^ k）= theta（3 ^ log（n，1.5））= theta（n ^ log（3,1.5））

Answer 4

可能有帮助：

/**********************************************************************
 * Complexity:
 * This algorithm makes exactly one comparison on each step.
 * On each step - algorithm divide initial array of size n :
 * on 3 arrays with (2*n / 3) sizes
 *                                           N
 *                                       /   |   \
 *                                   2N/3  2N/3  2N/3
 *                                   /
 *                              (2N/3)2/3
 *                                 /
 *                               ...
 *                               /
 *                           N * (2/3)^k = 1
 * By considering this tree we can find the depth - k:
 * N * (2/3)^k = 1                  =>>
 * N = 1 / (2/3)^k                  =>>
 * N = (3/2)^k                      =>>
 * log(3/2, N) = log(3/2, (3/2)^k)  =>>
 * k = log(3/2, N) (!!!)
 *
 * On each step algorithm makes 3^k comparisons =>> on the last step we will get:
 *                                     3^(log(3/2, N)) =>> N^(log(3/2, 3))
 * comparisons.
 *
 * We can compute the full work:
 * 1 + 3 + 9 + ... + 3^(log(3/2, N))
 * by using geometric progression formulas.
 * 
 *************************************************************************/
public static void sort(Comparable[] a, int lo, int hi) {
    if (lo >= hi) return;
    if (less(a[hi], a[lo])) exch(a, hi, lo);
    if (hi - lo + 1 > 2) {
        int t = (hi - lo + 1) / 3;
        sort(a, lo, hi - t);
        sort(a, lo + t, hi);
        sort(a, lo, hi - t);
    }
}

Answer 5

t（n）= 3·t（2 * n / 3）+Θ（n）

h = 1 + log _3/2（n）

尝试计算。这很容易。

在每个级别，我们都有复杂性3 ⁱ⋅c，其中c是某个常数，i是该特定级别的高度

t（n）=Σ_{i = 0，...，h}c⋅3ⁱ

t（n）= n-2 ^{log 3（n）} / 2 ^{log 3（n）+1}

然后是一个简单的几何级数。

Stooge Sort递归树的大O分析

5 个答案: