Algorithm 非尺寸条件下递归算法的时间复杂度

我有一个关于递归函数复杂性的问题 代码（C#）如下所示：

public void function sort(int[] a, int n)
{
    bool done = true;
    int j = 0;

    while (j <= n - 2)
    {
        if (a[j] > a[j + 1])
        {
            // swap a[j] and a[j + 1]
            done = false;
        {
        j++;
    }

    j = n - 1;

    while (j >= 1)
    {
        if (a[j] < a[j - 1])
        {
            // swap a[j] and a[j - 1]
            done = false;
        {
        j--;
    }

    if (!done)
        sort(array, length);
}

public void函数排序（int[]a，int-n）
{
bool done=true；
int j=0；
while（ja[j+1]）
{
//互换a[j]和a[j+1]
完成=错误；
{
j++；
}
j=n-1；
而（j>=1）
{
if（a[j]

现在，我遇到的困难是函数的递归部分。
到目前为止，在我看到的所有递归中，我们都可以根据输入大小确定递归调用的数量，因为每次我们用较小的输入调用函数时，等等。
但是对于这个问题，递归部分并不取决于输入大小；相反，它取决于元素是否已排序。我的意思是，如果数组已经排序，函数将以O（n）运行，因为有两个循环，并且没有递归调用（我希望我对这部分的看法是正确的）。
我们如何确定递归部分的O（n）？

O（f（n））意味着无论输入大小如何（仅考虑输入大小），您的算法总是快于或等于f（n）。因此，您应该找到大小为n的输入的最坏情况

---

这一个看起来像是某种冒泡排序算法（虽然非常复杂），它是O（n^2）。在最坏的情况下，对排序函数的每次调用都取O（n），并且将最大的数字传输到数组的末尾-您有n个项，所以它的O（n）*O（n）=>O（n^2）。

这是冒泡排序。它是O（n^2）.由于算法交换相邻元素，运行时间与列表中的反转数成正比，即O（n^2）。递归数为O（n）.向后传递只会使它递归大约一半的时间，但不会影响实际的复杂性--它仍在做同样的工作量。

谢谢你的回答，但我的问题是我无法理解递归部分…你知道，在正常的冒泡排序中，你迭代整个数组并移动元素，直到数组是被排序的（即：迭代的总次数是已知的），但在这里，我们只依赖于布尔“done”值。我想你是说这两个过程导致递归部分被调用n/2次，但我如何“证明”呢？