寻找递归算法的复杂性？

Question

我无法找到递归方法的复杂性。我有一个算法可以按升序对数组的元素进行排序。基本上我所做的就是写下算法中的每个步骤以及最佳/最坏情况的执行次数，然后将每个情况的总和计算出来，然后找到 Big-O/Big-Omega。但我不确定递归调用？我是否记下它在方法内被调用的次数，或者它被调用的总次数（可能会有所不同）？

所以假设我有一个数组 A = [5, 4, 3, 2, 1]（如果我没记错的话，这将是最坏的情况），那么我首先会遍历数组while 循环（参见下面的算法），然后在第二个 while 循环中再次向后，然后是递归调用。总的来说，我调用了我的方法一次（原始调用），然后是第二次，然后是第三次（没有进入 if 语句）。所以这是 n = 5 个元素的数组的 3 倍。但是在方法本身内部，递归调用发生了一次。我很混乱！ :S

另外，时间复杂度和空间复杂度有什么区别？任何提示/建议都会有所帮助。

谢谢！

这是给定的算法：

Algorithm MyAlgorithm(A, n) 
    Input: Array of integer containing n elements 
    Output: Possibly modified Array A 
        done ← true 
        j ← 0 
        while j ≤ n - 2 do 
            if A[j] > A[j + 1] then 
                swap(A[j], A[j + 1]) 
                done:= false 
            j ← j + 1 
        end while 
        j ← n - 1 
        while j ≥ 1 do 
            if A[j] < A[j - 1] then 
                swap(A[j - 1], A[j]) 
                done:= false 
            j ← j - 1 
        end while 
        if ¬ done 
            MyAlgorithm(A, n) 
        else 
           return A

这是我的解决方案：

Statement                Worst Case         Best Case
------------------------------------------------------------------
done = true                  1                  1
j = 0                        1                  1
j <= n-2                     n                  n
A[j] > A[j+1]                n-1                n-1
swap(A[j], A[j+1])           n-1                0
done = false                 n-1                0
j = j + 1                    n-1                n-1
j = n - 1                    1                  1
j >= 1                       n-1                n-1
A[j] < A[j-1]                n-1                n-1
swap(A[j-1], A[j])           n-1                0
done = false                 n-1                0
j = j - 1                    n-1                n-1
if ¬done                     1                  1
MyAlgorithm(A, n)            1                  0
return A                     1                  1
------------------------------------------------------------------
Total:                       10n-2                6n
Complexity:                  f(n) is O(n)         f(n) is Omega(n)

这也是我在 stackoverflow 上的第一篇帖子，所以我不确定我是否正确发布了这些帖子。

Answer 1

看起来这个算法是冒泡排序的某种变体。假设它工作正常，它的性能应该是O(n^2)。

要分析性能，你应该注意到过程体（没有递归）占用O(n)，所以算法占用的总时间是O(R n)，其中R是循环的次数递归在完成之前被调用。由于每个冒泡通道应该在最终的排序位置留下至少一个元素，R<=n/2，因此整个算法是 O(n^2) 最坏的情况。

不幸的是，在您的算法中使用递归的方式对于确定其性能并不是特别有用：您可以轻松地将递归替换为围绕构成过程主体其余部分的两个气泡通道的外部 while 循环（这可能避免了你的大部分困惑......）。

对递归分析有用的算法通常具有某种分而治之的结构，其中递归过程调用解决较小的子问题。您的算法明显缺乏这一点：递归调用的大小始终与原始调用相同。