Question

以下是我对此方法的尝试。

计算字符串str中的非空子字符串sub的共存数量。

numOccurances（“dogmonkeydog”，“dog”）将返回2

numOccurances（“dogmonkeydog”，“mon”）将返回1

numOccurances（“dogmonkeydog”，“cow”）将返回0

public static int numOccurrences(String str, String sub) {
    int result = 0;
    int pos = str.indexOf(sub);
    if (pos == -1){
        return result;
    }
    if (sub.length() > str.length()){
        return result;
    }
    if ((str.substring(0, sub.length())).equals(sub)){
        result++;
        String st = str.substring(pos);
        return result + numOccurrences(st, sub); //Line 87
    }
    else{
        String st = str.substring(sub.length());
        return result + numOccurrences(st, sub);
    }
}

我对所有结果＆gt;的测试都失败了0

java.lang.StackOverflowError
    at java.lang.String.indexOf(String.java:1718)
    at java.lang.String.indexOf(String.java:1698)
    at eecs2030.lab6.RecursiveTasks.numOccurrences(RecursiveTasks.java:77)
    at eecs2030.lab6.RecursiveTasks.numOccurrences(RecursiveTasks.java:87)

我不确定为什么我的代码永远不会达到它的基本情况，任何见解都会非常感激！

Answer 1

不需要方法中的第三个if条件。

 if ((str.substring(0, sub.length())).equals(sub))

你可以简单地将第三种情况定义为

 if(pos>=0)
  {
  result++;
  String newstr = str.substring(pos + sub.length());
  return numOccurrences(newstr,sub);
  }

因为，如果找到子字符串，则通过启动子字符串的索引来初始化pos变量，你可以在这里增加结果。

然后递归调用其余字符串上的numOccurences（）方法。并在方法之外声明变量结果。

 import java.util.Scanner;
 class SubString
 {
 String user,subUser;
 Scanner sc=new Scanner(System.in);
 int num;
 static  int result = 0;
 int numOccurrences(String str, String sub) {

  int pos = str.indexOf(sub);
  if (pos == -1){
    return result;
 }
 if (sub.length() > str.length()){
    return result;
  }
  else if(pos >= 0)
  {
   result++;
   String newstr = str.substring(pos + sub.length());
   return numOccurrences(newstr,sub);
   }
 return result;

 }

//constructor
 SubString()
 {
   try{
   System.out.println("Enter string :");
   user=sc.nextLine();
   System.out.println("Enter the substring: ");
   subUser=sc.nextLine();
   num = numOccurrences(user,subUser);
   System.out.println(num);
  }
   catch(Exception e)
   {
    System.out.println(e);
   } 

 }
 public static void main(String...a)
{
 new SubString();
 }
 }

`

Answer 2

1 : public static int numOccurrences(String str, String sub) {
2 :    int result = 0;
3 :    int pos = str.indexOf(sub);
4 :    if (pos == -1){
5 :        return result;
6 :    }
7 :    if (sub.length() > str.length()){
8 :        return result;
9 :    }
10:    if ((str.substring(0, sub.length())).equals(sub)){
11:        result++;
12:        String st = str.substring(pos);
13:        return result + numOccurrences(st, sub); 
14:    }
15:    else{
16:        String st = str.substring(sub.length());
17:        return result + numOccurrences(st, sub);
18:    }
19:}

第10行 - 您没有在实际字符串sub中提取给定str字符串参数的子字符串。
第12行 - 您几乎在那里丢弃当前子字符串以进行下一次调用，但您也包含该字符串。示例： monstrfri - ＆gt;使用子字符串 str 将导致 strfri 而不是 fri

如果您更喜欢更改逻辑，可以通过简单的while循环来实现 pos是子串的索引

counter is 0
while pos!=-1
    increment the counter
    trim the current substring found
    extract the next position
    and continue while

Answer 3

这似乎是一项学校作业。所以，我不会直接给你答案。

在以下代码段中，

result++;
String st = str.substring(pos);
return result + numOccurrences(st, sub); //Line 87

您创建st的地方存在问题。如果str以sub中包含的值开头，则str将等于st。因此，对numOccurrences的调用与原始调用相同，因此您的递归不会终止。

分析上述代码段中需要传递给str.substring的内容。

希望这有帮助！

Answer 4

      public static int findOcc(String str,String sub){
        int count =0;
        int occurence = 0;
        char strArray [] = str.toCharArray();
        char subArray [] = sub.toCharArray();
        for(int i=0;i<strArray.length;i++){
            if(strArray[i]==subArray[0]){
              for(int j=0,k=i;j<subArray.length && k < strArray.length 
              ;j++,k++){
                        if(strArray[k]==subArray[j]){
                          count++;
                        }
                       }
                       if(count == subArray.length){
                          occurence++;
                 }
                 count =0;
              }
         }
      return occurence;
    }

计算字符串中字符串的出现次数

4 个答案: