Algorithm Stooge排序递归树的大O分析_Algorithm_Big O

Algorithm Stooge排序递归树的大O分析

algorithm big-o

Algorithm Stooge排序递归树的大O分析,algorithm,big-o,Algorithm,Big O,我正试图找到一个大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 )

我正试图找到一个大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

算法stoogesort（数组L，i=0，j=length（L）-1）
如果L[j]1，那么
t=（j-i+1）/3
斯托格斯波特（L，i，j-t）
斯托格斯波特（L，i+t，j）
斯托格斯波特（L，i，j-t）
返回L

我不擅长性能分析。。。我画了递归树

我相信…：

高度：
```
log（n）
```
在级别0上工作：n//我是从级别0还是从级别1开始
1级工作：2n
2级作业：4n
3级作业：8n
在级别日志（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））

相比，k级问题的规模为（2/3）kn。最低层的尺寸为1，因此设置（2/3）kn=1，深度为k=log1.5 n（将两侧除以（2/3）k，以1.5为基准）

级别k的调用数为3k。在k=log1.5n级别，这是3log1.5n=（（1.5）log1.53）log1.5n=（（1.5）log1.5n）log1.53=nlog1.53=nlog3/log1.5

由于每一层的功都以几何级数增加，因此叶的功占主导地位。

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

你可以用这个函数来求解，答案是θ（n^log（3,1.5））=θ（n^log（3/1.5））

你也可以证明在n上使用归纳法

使用递归树也是可以接受的：
k=级别数=对数（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））

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

h=1+log3/2（n）

试着计算一下。这很容易

在每一个层次上，我们都有复杂性3i⋅c、其中c是某个常数，i是该特定标高的高度

t（n）=∑i=0，…，hc⋅3i

t（n）=n-2log₃（n） /2log₃（n） +1

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

您可以使用找到这个答案。从算法中可以看出，递推关系为：

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

应用该定理：

f（n）=1=O（nc），其中c=0。 a=3，b=3/2=>log3/2（3）=~2.70

由于c

T（n）=O（nlog3/2（3））=O（n2.70）

这可能会有所帮助：

/**********************************************************************
 * 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);
    }
}

让我们说得出的结果并不是微不足道的：）我可能会尝试解释它，但有点晚了，

O（n^2 log（n））

等于

O（n^2）

？而且O（n^2*logn）仍然是O（n^2*logn），因为这是一个完整的因素，所以你离得不太远。@Kerrek，在大O中，我只保留了最高的“度”（忘记了正确的术语：

log（n）

），没有？更新：哦，是的…它不是一个加号…@JesusRamos:它相当远。n^2 log（n）
比n^（2+epsilon）
对于任何正的epsilon
。好的，你是如何计算高度k
？我做的。Can islog base 2/3（1/n）==log base 1.5（n） 
？你使用了哪一个对数公式？@jiewmeng log base b of x是log x/log b，log（1/x）=-log x。我们有log_（2/3）（1/n）=log（1/n）/log（2/3）=-log n/-log 3/2=log_1.5 n。我们首先如何计算出数字2/3？