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

我会给你一些提示：

当你找到这封信时，你不需要进一步递减。另外，想想在这种情况下你应该返回什么。
你何时递归，还要考虑应该返回的功能。
如果递归调用返回-1？

Answer 2

你的尝试很好，但并不完全。以下是基于您的正确实施：

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 3

这是另一种变化。您可以稍微修改函数以传递下一个要检查的索引，而不是调用子字符串。请注意，递归是从索引0开始的。（您实际上可以从任何索引开始。如果找不到该字母，还会进行一些错误检查。在apple中查找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);
}

输出：

Index: 4
Index: -1
Index: 8
Index: -1

Answer 4

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

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

首先：递归有两个支柱，基本案例和一般案例。

基本案例（终止点）是递归终止的那个，一般案例，顾名思义是程序执行的地方直到找到基本案例

您可以尝试此示例，其中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
}

使用递归来查找字符串中的字符

6 个答案: