包含“bab”的布尔函数

Question

我怎么会有一个递归布尔方法来检查它是否包含bab。我有这个，但我想递归地做。

public static boolean hasBAB(String str) {
      if (str.length() < 3) return false;
      if (str.substring(0,3).equals("bab"))
        return true;
      else
        return false;
    }

Answer 1

public static boolean hasBAB(String str) {
  if (str.length() < 3) return false;
  if (str.substring(0,3).equals("bab"))
    return true;
  else
    return hasBAB(str.substring(1));
}

但你真的应该使用String.contains

Answer 2

无需递归；）您正在寻找String.contains

public static boolena hasBAB (String str) {
    if (String.length() < 3) return false;
    else return str.contains("bab");
}

Answer 3

递归应该被认为是两个部分。

1) 基本情况。这是很容易确定的微不足道的情况。 到目前为止，您所拥有的是基本案例的良好开端。 1) 字符串是否小于 3？然后返回假。 2）字符串是否以“bab”开头然后返回true。

2) 递归情况。 这会将问题拆分为更小的问题，如果您将它们拆分得足够多，希望您有一个基本案例。

@Logiraptro 有一个简单递归的好例子。

public static boolean hasBAB(String str) {
  if (str.length() < 3) return false;
  if (str.substring(0,3).equals("bab"))
    return true;
  else
    return hasBAB(str.substring(1));
}

这使用您的基本情况，并作为递归情况检查从索引一开始的字符串。这仅将我们的字符串减少了一个章程，但足以解决问题。

这意味着我们最终得到了字符串长度的堆栈级别。

我们可以做得更好吗？稍微，通过将问题分成两半，我们只需要 ln(n) 的堆栈级别，其中 n 是字符串的长度。对于大多数长度而言，这并不是什么大问题，但如果您正在搜索长度为一百万的字符串，它可能很重要。在第一个版本中，我们的堆栈深度约为 1,000,000！但有了这个二进制版本，我们只需要深入 14 层即可。

不过，这是有代价的，因为我们的解决方案涉及更多。

我们的基本案例 1) 如果字符串小于搜索字符串的长度，则返回 false。 2）如果字符串是搜索字符串的长度，如果相等则返回true，否则返回false。 3) 如果字符串出现在字符串的中点之上，则返回 true。

如果这些都不正确，我们将字符串分成两部分并递归检查该字符串。

这是该算法的一个示例，您可以将“bab”替换为您喜欢的任何字符串，尽管它尚未经过全面测试，我很确定它会没问题。

public static boolean hasBAB(String str) {
      String searchString = "bab";

      // Base cases
      if (str.length() < searchString.length()) 
          return false;

      if (str.length() == searchString.length())
      {
          if (str.equals(searchString))
          {
              return true;
          }
          return false;
      }

      int halfWay = str.length()/2;

      // Now check for the search string over the "break"
      for (int i = 0; i < searchString.length(); i++)
      {
          int startIndex = halfWay - 1 - i;
          int endIndex = startIndex + 3;
          if (startIndex >= 0)
          {
              String substring = str.substring(startIndex, endIndex);
              if (substring.equals(searchString))
              {
                  return true;
              }
          }
      }

     // Recursive Cases 
     //  We did find the search string over the break,so break the string into two equal(ish) pieces and check those 
     if(hasBAB(str.substring(0,halfWay -1)))
         return true;

     if(hasBAB(str.substring(halfWay, str.length())))
         return true;

     return false;
}