Question

以下是我正在尝试使用此程序完成的任务：一种递归方法，用于检查子字符串的实例数是否与指定数量的实例匹配，返回布尔值。

这是我对这个特殊的递归方法的问题：我希望能够在递归方法体内移动计数器，但是，我遇到了计数器在每次递归调用时重置的问题在方法体中。我能够使它工作的唯一方法是使用在函数体外部声明的静态计数器变量。为了能够将方法的计数器置于方法体中，以便该方法可以充当“黑盒子”，是否还有其他技术可以编组？

感谢您提供任何建议或见解。

public class strCopies {

    //count instances of part and whole equality
    static int count = 0;

    public static boolean copies(String whole, String part, int check)
    {

        //check if current string length is valid
        if(whole.length() < part.length())
        {
            //check if check parameter equals part instances
            if(count == check)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        //check if current string value is an instance of part 
        if(whole.substring(0, 3).equals(part))
        {
            count++;
        }

        //recursive call
        return copies(whole.substring(1), part, check);

    }

    public static void main(String[] args)
    {
        System.out.println(copies("dogcatdog", "cat", 2));
    }
}

Answer 1

您几乎就在那里：您应该将check变量的含义更改为剩余匹配数，而不是请求的原始数。然后，您可以重写该方法，而无需保留额外的计数，如下所示：

public static boolean copies(String whole, String part, int check)
{

    //check if current string length is valid
    if(whole.length() < part.length())
    {
        //check if check parameter equals part instances
        if(check == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    //check if current string value is an instance of part 
    if(whole.substring(0, 3).equals(part))
    {
        check--;
    }
    return return copies(whole.substring(1), part, check);
}

Answer 2

简单版本：

创建一个包含计数器的类。在您的主要上初始化它。将其引用传递给函数。

另一个想法：

使用静态计数器和函数X创建单例类。在它的构造函数中添加一个到它的计数器并调用函数X。

然后不像以前那样运行你的函数，而是“创建”那个类，从而增加计数器并调用函数。

巧妙的是，您可以继承该类并将X重新定义为您在后一阶段选择的任何内容，因此您可以获得这个通用类，它依赖于函数的每次激活。

Answer 3

public int countRecursive(String whole, String part){
    if(whole.length() < part.length()) return 0;
    if(part.length()==0) return -1; // ints can't express "Infinity" 
    // maybe you want to return -1 only if whole is not null, and something else if it is.       

    int count = 0;

    if(whole.substring(0, part.length()).equals(part))
        count = 1;
    return countRecursive(whole.substring(1), part) + count;
}

public boolean count(String whole, String part, int check){
    return countRecursive(whole, part) == check;
}

请注意，这会消除计数器，代价是为每个状态创建一大堆字符串。（你用给定的每个字符串的长度替换一个int。）但是再次，如果你想要性能，那么你不应该使用递归来做这样的事情。一个简单的for循环可以做得更好。

Answer 4

您可以将计数器添加到方法参数中，如下所示：

public class strCopies {

    public static boolean copies(String whole, String pargs, int check){
        return copies(whole, pargs, check, 0);
    }

    public static boolean copies(String whole, String part, int check, int count)
    {

        //check if current string length is valid
        if(whole.length() < part.length()) {
            //check if check parameter equals part instances
            if(count == check) {
                return true;
            }
            else {
                return false;
            }
        }

        //check if current string value is an instance of part
        if(whole.substring(0, 3).equals(part)) {
            count++;
        }

        //recursive call
        return copies(whole.substring(1), part, check, count);

    }

    public static void main(String[] args) {
        System.out.println(copies("dogcatdog", "dog", 2));
    }
}

Answer 5

您可以将计数作为参数传递给递归函数，这样在调用方法时它不会被“重置”。

public static boolean copies(String whole, String part, int check, int count)
{

    //check if current string length is valid
    if(whole.length() < part.length())
    {
        //check if check parameter equals part instances
        if(count == check)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    //check if current string value is an instance of part 
    if(whole.substring(0, 3).equals(part))
    {
        count++;
    }

    //recursive call
    return copies(whole.substring(1), part, check, count);

}

Answer 6

不确定你的递归方法在做什么。但是，要维护计数器，可以将其作为参数传递给递归方法。

public boolean copies(String whole, String part, int check, int count) {

    // your code here....

    if(whole.substring(0, 3).equals(part))
    {
        count++;
    }

    //recursive call
    return copies(whole.substring(1), part, check, count);
}

当您第一次拨打copies方法时，您需要将0传递给count。

保持递归Java方法的计数

6 个答案: