Question

此特定递归如何工作 return (X.charAt(m-1) == Y.charAt(n-1) ? count(X, Y, m-1, n-1) : 0) + count(X, Y, m-1, n)

在下面的代码中？

以下代码将返回模式在给定字符串中作为子序列出现的次数。

class Subsequence {
    public static int count(String X, String Y, int m, int n) {
        if (m == 1 && n == 1)
            return X.charAt(0) == Y.charAt(0) ? 1 : 0;
        if (m == 0)
            return 0;
        if (n == 0)
            return 1;
        if (n > m)
            return 0;

        return (X.charAt(m - 1) == Y.charAt(n - 1) ? count(X, Y, m - 1, n - 1) : 0) + count(X, Y, m - 1, n);
    }

    public static void main(String[] args) {
        String X = "subsequence";//input String
        String Y = "sue";// pattern
        System.out.print(count(X, Y, X.length(), Y.length()));
    }
}

Answer 1

它的工作原理如下：

if(X.charAt(m-1) == Y.charAt(n-1))
    return count(X, Y, m - 1, n - 1);
else
    return 0;    //since no match found here

现在，上面的代码是使用三元运算符的return语句的第一行的破坏。 不要认为这是对此代码的彻底细分。

所以，一旦你得到这个语句，下一步就是再次调用这个函数来查找从第一个字符串中的m-开始和模式字符串中的n开始的任何匹配字符，因为我们需要从一开始就仍然匹配整个模式。但是，如果我们找到匹配项，我们只是继续匹配模式和字符串中剩余的可用字符。

但说实话，与这种方法相比，有许多更好的方法来编码模式匹配算法。

Answer 2

您经常会发现正确地重命名变量并添加一些澄清注释会产生奇迹。

public static int count(String string, String pattern, int stringLength, int patternLength) {

    if (stringLength == 1 && patternLength == 1) {
        // Two length=1 strings -> if they are equal then they match - obviously.
        return (string.charAt(0) == pattern.charAt(0)) ? 1 : 0;
    }
    if (stringLength == 0) {
        // No more string to search - no-match.
        return 0;
    }
    if (patternLength == 0) {
        // No more pattern to search - MATCH!
        return 1;
    }
    if (patternLength > stringLength) {
        // Can never find a pattern longer than the string.
        return 0;
    }

    return ((string.charAt(stringLength - 1) == pattern.charAt(patternLength - 1)) ?
            // Both end with same character - recurse to keep matching.
            count(string, pattern, stringLength - 1, patternLength - 1)
            // Not match.
            : 0)
            // ADD any matches further down the string. 
            + count(string, pattern, stringLength - 1, patternLength);
}

可悲的是，代码在某处错误 - 在sue subsequence 7中搜索export class rootComponent{ iSActive = true; setVal(j){ if(j==0){ this.iSActive = false; } } }。

Answer 3

我认为它被称为＆＃34;三元运算符＆＃34;，它是以更紧凑的方式执行IF语句的另一种方式（即，如果为了可读性而同时加载它们）。它必须有某个地方给出返回值（例如变量或返回语句）

作为一个例子，它看起来像这样

boolean test;
if (condition) {
    test = true;
} else {
    test = false;
}

与写作

相同

function recursiveCount(stringStart, stringEnd, startLocation, endLocation) {
    /* pre-checks */

    // Total will be how many times it loops (1 + 1 + 1 + 1 + 1 basically what it is doing)
    // If there is no more occurances of that string it adds 0 instead of 1, and the recursion breaks.
    return (total + recursiveCount(stringStart, stringEnd, nextStartLocation, nextEndLocation)
}

CodeHunter的回答是一个很好的例子，说明你给出的示例代码如何转回if语句。

它做的是：（的伪）

{{1}}

这个特定的递归是如何工作的

3 个答案: