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

我正在处理一些实践问题，其中一个是获取两个字符串并确定其中一个是否是另一个的子字符串。我写了我的第一个解决方案：

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;
}

公共静态布尔IsubString（字符串s1、字符串s2）{
字符串长度=s1.length（）>s2.length（）？s1:s2；
字符串较短=s1.length（）

由于我在练习，而且我不太擅长递归，我认为我应该尝试递归地解决这个问题，但我没有能够正确地这样做。我如何用递归来解决这个问题，与上面的解决方案相比，在这里使用递归有什么优点/缺点。下面是我尝试递归解决这个问题的失败尝试：

 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);


}

公共静态布尔IsubStringRecursive（字符串s1、字符串s2、int i）{
如果（s1.length（）==0 | | s2.length（）==0）
返回false；
字符串长度=s1.length（）>s2.length（）？s1:s2；
字符串较短=s1.length（）

编辑

测试用例： 字符串A=“蝙蝠侠”字符串B=“atm”结果：真

字符串A=“倒立”字符串B=“站立”结果：真

---

String A=“hotsoup”String B=“ecu”RESULT:False

我正在对您的例程进行最小的更改以使其正常工作。有关解释，请参阅代码中的注释

/* 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); 

}

/*添加一个额外的参数，以便在多个递归中不断存储最长的值*/
公共静态布尔isSubstringRecursive（字符串longString、字符串s1、字符串s2、int i）{
如果（s1.length（）==0 | | s2.length（）==0）
返回false；
字符串长度=s1.length（）>=s2.length（）？s1:s2；
字符串较短=s1.length（）longString.length（））返回false；
/*使用longString作为子字符串，因为它包含最初的长字符串*/
返回isSubstringRecursive（longString，longString.substring（i，i+shorter.length（）），shorter，i+1）；
}

这段代码可以在很大程度上进一步优化，但我将把这部分留给您做进一步的工作

注意1：正如您所说，您可以使用String类的“contains”方法轻松实现这一点。但是，在您为

contains

演示的解决方案中，您实际上不必检查字符串长度。请参阅以下内容：

返回s1.contains（s2）| s2.contains（s1）；

注意2：您也可以使用String类的

索引来执行相同的操作。请参见以下内容：

return（s1.indexOf（s2）！=-1 | | s2.indexOf（s1）！=-1）；

长话短说，有这么多更容易的选项来实现您的目标，因此不需要使用
递归
选项。
您有测试用例吗？递归是数字化的循环-您的工作代码中没有循环：为什么您认为您需要递归？我建议您的基本用例和使用
startsWith
de>子字符串（1）

用于递归。如果长字符串以短字符串开头，则结束。否则，请删除第一个字符并递归。@Assylas我的第一个解决方案中有一个循环；递归不是我需要的东西，而是我需要学习如何正确操作的东西。@ElroyJetson关于递归的一个很好的页面。它得到了递归的核心是什么：把大问题（例如一棵树）分解成小问题（例如到节点）谢谢。感觉很好，我在递归的正确轨道上。我同意这样的问题是不必要的，但是感谢你抽出时间来帮助我提高我的技能。

/* 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); 

}