Question

我正在经历一些练习问题，其中一个是拿两个字符串并确定一个是否是另一个的子字符串。我写了第一个解决方案：

public static boolean isSubstring(String s1, String s2){
    String longer = s1.length() > s2.length() ? s1 : s2;
    String shorter = s1.length() < s2.length() ? s1 : s2;
    String substring;

    for(int i = 0; i < longer.length() && i + shorter.length() <= longer.length(); i++){
        substring = longer.substring(i, i + shorter.length());
        if(substring.equals(shorter))
          return true;
    }
    return false;
}

然后我记得Java有一个String类的包含方法，而且解决方案在这一点上是微不足道的。：

public static boolean isSubstringUsingContains(String s1, String s2){
  String longer = s1.length() > s2.length() ? s1 : s2;
  String shorter = s1.length() < s2.length() ? s1 : s2;
  return longer.contains(shorter);

}

由于我正在练习并且我不太擅长递归，我认为我应该尝试递归地解决这个问题，而且我无法正确地解决这个问题。我如何通过递归来解决这个问题，并且在这里使用递归有任何优点/缺点，而不是上述解决方案。这是我对这个问题的递归解决方案失败的尝试：

 public static boolean isSubstringRecursive(String s1, String s2,int i){
  if(s1.length() == 0 || s2.length() == 0)
   return false;

  String longer = s1.length() > s2.length() ? s1 : s2;
  String shorter = s1.length() < s2.length() ? s1 : s2;

  if(longer.equals(shorter))
     return true;

  return isSubstringRecursive(longer.substring(i,i + shorter.length()),shorter,i + 1);


}

编辑

测试案例： String A =“Batman”String B =“atm”RESULT：True

String A =“Handstand”String B =“stand”RESULT：True

字符串A =“Hotsauce”字符串B =“ecu”结果：错误

Answer 1

我正在对您的日常工作进行微小的更改以使其正常工作。请参阅我在代码中的评论进行解释。

/* Adding an extra argument to store the longest value constantly across multiple recursions. */
public static boolean isSubstringRecursive(String longString, String s1, String s2,int i){

  if(s1.length() == 0 || s2.length() == 0)
   return false;

  String longer = s1.length() >= s2.length() ? s1 : s2;
  String shorter = s1.length() < s2.length() ? s1 : s2;

  /* set the longString in the first iteration only */
  if(i==0)longString=longer;

  if(longer.equals(shorter))
     return true;

  /* To prevent substring to go out of boounds */
  if(i+ shorter.length() > longString.length()) return false;

  /* Use longString for substring since it holds the originally long string */
  return isSubstringRecursive(longString, longString.substring(i,i + shorter.length()),shorter,i + 1); 

}

此代码可在很大程度上进一步优化。但我会把这部分留给你进一步的工作。

注1 ：正如您所说，您可以使用String类的'contains'方法轻松实现此目的。但是，在您为contains演示的解决方案中，您实际上不必检查字符串长度。请参阅以下内容：

return s1.contains(s2) || s2.contains(s1);

注意2 ：您也可以使用String类的indexOf来执行相同的操作。请参阅以下内容：

return (s1.indexOf(s2) != -1 || s2.indexOf(s1) != -1);

长话短说，有很多更容易实现目标的选项，无需选择recursion。

给定两个字符串，确定1是否是另一个递归的子字符串

1 个答案: