min-max 算法的复杂性

Question

我有以下代码。它应该保持什么样的递归关系以及它的复杂性是什么。如果你能帮我找到它的复杂性，用替换方法解决递归关系，那就太好了。

存储多个返回值的节点变量

struct node
{
    int MAXX;
    int MINN;
}NODE;

从给定数组中找到最小和最大数字的递归函数

struct node partition(int a[], int first, int last)
{
    int MAX, MIN;
    int low = first;
    int high = last;
    struct node left, right;

    /*If there is a single variable */
    if (low==high)
    {
        NODE.MAXX = a[low];
        NODE.MINN = a[low];
        return(NODE);
    }
    /*If there exists only 2 elements*/
    else if (high==low+1)
    {
        if (a[high]>a[low])
        {
            NODE.MAXX = a[high];
            NODE.MINN = a[low];
        }
        else
        {
            NODE.MAXX = a[low];
            NODE.MINN = a[high];
        }
        return NODE;
    }
    /*If there exists more than 2 elements */
    int mid = (low + high) / 2;
    left=partition(a, low, mid);
    right=partition(a, mid+1, high);
    if (left.MAXX > right.MAXX)
        NODE.MAXX = left.MAXX;
    else
        NODE.MAXX = right.MAXX;
    if (left.MINN < right.MINN)
        NODE.MINN = left.MINN;
    else
        NODE.MINN = right.MINN;

    return NODE;

}

主要功能

int _tmain(int argc, _TCHAR* argv[])
{
    struct node N;
    int a[] = { 70, 50, 111, 69, 4, 7, 80, 100 }; 
    N=partition(a, 0, 7);
    cout << "Maximum = " << N.MAXX << endl;
    cout << "Minimum = " << N.MINN << endl;
}

Answer 1

对partition 的每次调用都会执行固定数量的工作，外加 2 次额外的递归调用，每次调用都有 一半 的输入索引范围。因此，我们可以为时间复杂度函数构造一个递归关系：

T(n) = 2T(n/2) + C

这扩展为几何级数C * (1 + 2 + 4 + ... )，并持续到log n 项（因为在每个递归级别，输入大小减半，因此它以几何方式减小到停止条件n = 2）。从标准公式来看，这相当于O(n)。

---

编辑：改进先前解释的方程式：