Question

整个问题：给定从1到n的索引包含整数的数组A，确定A [1到n]中有多少整数大于A [1]

到目前为止我写的内容：

static int numGreater(int A[], int n, int count)
{
    if(A[1] == A[n])
    {
        return count; 
    }
    else 
    {
        count = (A[1] < A[n] ? count : + 1);
        return numGreater(A, n - 1, count);
    }
}

有点难过。在递归中编码仍然是新的。

Answer 1

我终于明白了。问题是，我知道有一种方法我不必对参数进行“计数”，但我不知道该怎么做。我做的是。

Option Explicit
Option Compare Text
Sub HelloStart()
    Dim wsSrc As Worksheet, wsRes As Worksheet, rRes As Range
    Dim vSrc As Variant, vRes As Variant
    Dim COL As Collection
    Dim MaxCols As Long
    Dim V As Variant, W As Variant
    Dim I As Long, J As Long


Set wsSrc = Worksheets("sheet1")
Set wsRes = Worksheets("sheet2")
    Set rRes = wsRes.Cells(1, 1)

With wsSrc
    vSrc = .Range(.Cells(1, 1), .Cells(.Rows.Count, 1).End(xlUp))
End With

Set COL = New Collection
For Each W In vSrc
    Select Case W
        Case Is = "Hello"
            If Not IsEmpty(V) Then
                COL.Add V
                MaxCols = IIf(MaxCols > UBound(V), MaxCols, UBound(V))
            End If
            ReDim V(1 To 1)
            V(1) = W
        Case Else
            ReDim Preserve V(1 To UBound(V) + 1)
            V(UBound(V)) = W
    End Select
Next W
If Not IsEmpty(V) Then COL.Add V
MaxCols = IIf(MaxCols > UBound(V), MaxCols, UBound(V))

ReDim vRes(1 To COL.Count, 1 To MaxCols)
I = 0
For Each V In COL
    I = I + 1
    J = 0
    For Each W In V
        J = J + 1
        vRes(I, J) = W
    Next W
Next V

Set rRes = rRes.Resize(UBound(vRes, 1), UBound(vRes, 2))
wsRes.Cells.Clear
With rRes
    .Value = vRes
    .EntireColumn.AutoFit
End With

End Sub

我很确定有更好的方法可以做到这一点，我仍然想知道它们以扩大我对递归的理解。将会有更多的答案。

Answer 2

由于你自己已经回答了这个问题，我将添加我的2位，并提供一些关于如何避免在变量中保留计数并将其作为递归方法中的参数传递的可视化解释。

Discalimer：我正在使用Java的数组索引约定，因为像你这样的问题语句可能不是特定于语言的，并且从1-n索引Java数组而不是0-（n-1）是没有意义的，因为这样做所需的额外元素。话虽如此，我认为它们意味着一个数组由填充数组的n个元素组成。我也从阵列的开头开始并朝着最后的方向努力;在这方面没有区别，因为在任何一种情况下，堆栈都会将值返回给调用者。

下面的粗略描述非常明显。 |_..._|显示与相关递归方法调用进行比较的值。在第一次调用时，我们检查基本情况，如果不满足，我们再次使用下一个索引调用该方法;我们会继续这样做，直到我们达到基本情况（n == A.length）。一旦我们到达终点，我们将0返回到前一个调用，该调用返回其值以及下一个调用的值（正在进行的计数）。我们继续这样做，直到我们回到调用者。

    0     1     2     3 : indices
    -------------------
    3     5     3     6 : values
    |_____|     |     |
    |___________|     |
    |_________________|
<--------2| <--1| <--1| <--0| : return values
    -------------------------
          1     2     3     4 : call stack (4 = base case)

以下是执行此操作的代码：

static int numGreater(int[] A, int n) {
    if (n == A.length) return 0;
    return (A[0] < A[n] ? 1 : 0) + count(A, n + 1);
}

现在，您应该能够看到每个非基本情况的方法调用会根据1条件将0或A[0] < A[n]添加到下一个调用中，从而累积计数当堆栈展开时，不需要计数变量。

请注意，您还应该能够了解为什么检查第一个和 i-th 元素之间的相等性是不可行的，因为它可能会使递归短路导致计数错误。

Answer 3

终止：如果n小于2 - 您无需比较。

递归步骤：如果A[n] > A[1]在结果中加1并调用递归函数。

static int numGreater(int A[], int n)
{
    if (n < 2) return 0;
    return A[n] > A[1] 
        ? 1 + numGreater(A, n - 1)
        : numGreater(A, n - 1);
}

Java Recursion：确定数组中的数字大于索引1的数量

3 个答案: