使用递归在字符串中查找字符

Question

我正在尝试查找字符串中第一次出现的字母。例如，苹果中的 p 应该返回 1。这是我所拥有的：

// Returns the index of the of the character ch
public static int indexOf(char ch, String str) {

    if (str == null || str.equals("")) {
        return -1;
    } else if(ch == str.charAt(0)) {
        return 1+ indexOf(ch, str.substring(1));
    }

    return indexOf(ch, str.substring(1));
}

它似乎没有返回正确的值。

Answer 1

你的尝试很好，但还不够。这是基于您的正确实现：

public static int indexOf(char ch, String str) {
    // Returns the index of the of the character ch

    if (str == null || str.equals("")) {
        // base case: no more string to search; return -1
        return -1;
    } else if (ch == str.charAt(0)) {
        // base case: ch is at the beginning of str; return 0
        return 0; 
    }

    // recursive step
    int subIndex = indexOf(ch, str.substring(1));

    return subIndex == -1 ? -1 : 1 + subIndex;
}

您的尝试有两个问题：

在else if 部分，您找到了角色，因此正确的做法是停止递归，但您仍在继续。

在您的最后一个 return 语句中，您需要将 1 添加到递归调用（如果最终找到该字符），作为累积总索引号的一种方式。

Answer 2

首先：递归有两大支柱，Base Case和General Case。

Base Case（终止点）是 Recursion 终止的地方，而 General Case 顾名思义是程序继续执行的地方直到找到 Base Case

你可以试试这个例子，其中count 是一个全局变量static

public static int indexOf(char ch, String str)
{
  // Returns the index of the of the character ch
  if (str == null || str.Equals(""))     //Base Case
  {
     if (count != 0)
     {
        if(str.Length == 0)
           return -1;  
        return count;
     }
     else
        return -1;          
  }
  else if (ch == str.CharAt(0))          //Base Case  
     return 1 + count; 
  count++;
  return indexOf(ch, str.Substring(1));  //General Case
}

Answer 3

如果我们必须使用递归，那么试试这个：

class RecursiveFirstIndexOf {

public static void main(String[] args) {
    System.out.println(indexOf('p', "apple", 0));
}

static int indexOf(char c, String str, int currentIdx) {

    if (str == null || str.trim().isEmpty()) {
        return -1;
    }

    return str.charAt(0) == c ? currentIdx : indexOf(c, str.substring(1), ++currentIdx);

}}

Answer 4

这是另一个变体。您可以稍微修改函数以传递下一个要检查的索引，而不是调用 substring。请注意，递归是从索引 0 开始的。（您实际上可以从任何索引开始。还有一些错误检查以防找不到字母。在苹果中查找 x 将返回 -1。）

public static void main(String []args){  
    System.out.println("Index: " + indexOf('e', "apple", 0));
    System.out.println("Index: " + indexOf('x', "apple", 0));
    System.out.println("Index: " + indexOf('p', "Mississippi", 3));
    System.out.println("Index: " + indexOf('p', "Mississippi", 908));
}

public static int indexOf(char ch, String str, int idx) {
    // check for garbage data and incorrect indices
    if (str == null || str.equals("") || idx > str.length()-1) 
        return -1;

    // check to see if we meet our condition
    if (ch == str.charAt(idx)) 
        return idx;

    // we don't match so we recurse to check the next character
    return indexOf(ch, str, idx+1);
}

输出：

指数：4 指数：-1 指数：8 指数：-1

Answer 5

为什么不直接做呢？

public static void main(String[] args) {
    String str = "abcdef";
    for (int idx = 0; idx < str.length(); idx++) {
        System.out.printf("Expected %d, found %d\n", idx, indexOf(str.charAt(idx), str, 0));
    }
    System.out.printf("Expected -1, found %d\n", indexOf(str.charAt(0), null, 0));
}

public static int indexOf(char ch, String str, int index) {
    if (str == null || index >= str.length()) return -1;
    return str.charAt(index) == ch ? index : indexOf(ch, str, ++index);
}

输出：

Expected 0, found 0
Expected 1, found 1
Expected 2, found 2
Expected 3, found 3
Expected 4, found 4
Expected 5, found 5
Expected -1, found -1

Answer 6

我会给你一些提示：

1. 找到这封信后，无需进一步递归。此外，请考虑在这种情况下您应该返回什么。
2. 什么时候递归，还要考虑函数应该返回什么。
3. 如果递归调用返回-1，有什么特别需要做的吗？