Question

附上我所做的事;有一个问题，递归粘在左递归调用上，并且不能继续正确的递归调用。无法弄清楚如何将递归返回到第一个位置并继续执行正确的递归调用。

Foo/Bar/Android

Answer 1

类似方法作为合并排序：

这是C中的递归解决方案： a 是你的数组， i 和 j 你的左右......

void minmax (int* a, int i, int j, int* min, int* max) {
int lmin, lmax, rmin, rmax, mid;
if (i == j) {
*min = a[i];
*max = a[j];
} else if (j == i + 1) {
if (a[i] > a[j]) {
  *min = a[j];
  *max = a[i];
} else {
  *min = a[i];
  *max = a[j];
}
} else {
mid = (i + j) / 2;
minmax(a, i, mid, &lmin, &lmax);
minmax(a, mid + 1, j, &rmin, &rmax);
*min = (lmin > rmin) ? rmin : lmin;
*max = (lmax > rmax) ? lmax : rmax;
}

}

虽然有很多不同且更容易的解决方案......

按提问者编辑： ...因为问题是关于C ++程序，这将是C ++版本

void minMax(int a[], int left, int right, int &min, int& max) {
    int lmin, lmax, rmin, rmax, mid;
    if (left == right)
    {
        min = a[left];
        max = a[right];
    }
    else if (right == left + 1)
    {
        if (a[left] > a[right])
        {
            min = a[right];
            max = a[left];
        }
        else
        {
            min = a[left];
            max = a[right];
        }
    }
    else
    {
        mid = (left + right) / 2;
        minMax(a, left, mid, lmin, lmax);
        minMax(a, mid + 1, right, rmin, rmax);

        if (lmin > rmin)
            min = rmin;
        else
            min = lmin;
        if (lmax > rmax)
            max = lmax;
        else
            max = rmax;
    }
}

Answer 2

更简单的递归是：

void minMax(int& A[], int index, const int& lenght, int& min, int& max)
{
if (A[index] < min) min = A[index]);
else if (A[index] > max) max= A [index];

if (++index < lenght) minMax(A, index, lenght, min, max);
}

在这种情况下，你只是递归地迭代，而不是左右。

递归地查找数组中的最小值和最大值

2 个答案: