Question

我必须编写以下递归方法：

public static int countA(String s)

然而，我发现如果不宣布计数器和位置变量就不可能做到这一点;像这样：

public static int countA(String s, int position) {

        int count = 0;

        if( s.charAt(position) == 'A' )
            count++;

        if( position + 1 < s.length() ) {
            count += countA(s, position + 1);
        }

        return count;
    }

如何简化我的答案，以便我的方法与列出的方法相同？

编辑：是的，我想计算字符串中的所有A。

Answer 1

试试这个：

public static int countA(String s) {
    int count = 0;

    if (s == null)
        return 0;

    if (s.length() == 0)
        return 0;

    if (s.charAt(0) == 'A')
        count++;

    return count + countA(s.substring(1));
}

Answer 2

有两种递归形式，

尾递归：返回值计算为当前子例程的值和下一个调用的返回值的组合。例如，

int factorial(int a) {
    if(a==0)
        return 1;
    else
        return a * factorial( a-1 );
}

基于累加器的递归：您通过添加其他参数来累积结果并返回累计值。

int factorial(int a, int fact) {
    if(a==0)
        return fact;
    else
        return factorial(a-1, a*fact);
}

显然你所拥有的是基于累加器的，而你可以将它改进为Tail递归。

尾递归被认为更具可读性，虽然它可能导致StackOverflow ！（没有双关语）。这是因为它必须在再次调用子例程之前将当前值推送到堆栈。当你进行大量此类调用时，此堆栈可能会超出其限制。

为了避免这个问题，有些编译器会优化尾递归到累加器。

Answer 3

怎么样：

public static int countA(String s) {
        if(s==null) return 0;
        if(s.length()==0) return 0;
        if( s.charAt(0) == 'A' )
        {
            return 1 + countA(s.substring(1));
        } else 
        {
            return countA(s.substring(1));
        }
    }

Answer 4

我觉得这样的事情应该可以解决问题这里我们假设countA返回String内部的As数

public static int countA(String s)
{
    if(s.length()==0) return 0;  // return 0 if string is empty
    else
    {
        // if the first char is A add 1 to the answer, recurse
        if(s.toCharArray()[0])=='A') return 1+countA(s.subString(1,s.length()));

        // else add nothing to the answer, recurse
        else return countA(s.subString(1,s.length()));
    }
}

Answer 5

您将position变量移出方法并将其设为static（因为您的countA()也是static）。

static int position = 0;
public static int countA(String s) {
    int count = 0;
    if( s.charAt(position) == 'A' )
        count++;
    if( position + 1 < s.length() ) {
        position++;
        count += countA(s);
    }
    return count;
}

Answer 6

理想情况下，您首先拥有终止条件，然后通常通过减少缩进/嵌套来简化代码，并为其执行“不执行任何操作”（通常需要比绝对要求多一次迭代）。

您也不需要本地变量！

public static int countA(String s, int position) {
    if (position == s.length())
        return 0;
    return (s.charAt(position) == 'A' ? 1 : 0) + countA(s, position + 1);
}

Java递归;我怎样才能简化我的所有内容？

6 个答案: