使用递归的 2 个索引之间的子字符串

Question

我开始学习 Java，目前我正在玩递归。

我想尝试创建一个 substring 方法，该方法将从两侧以 1 个字符作为子字符串，直到我们得到所需的字符串。

我设法完成了第一部分，但在弄清楚如何从后面插入子字符串时遇到问题。

n 和m 应该是我们想要在其间进行子串（包括）的索引。

在这个例子中方法的结果应该是“bstri”

这是我的代码：

public static void main(String[] args) {
    String s = "substringme";

    System.out.println(rec(s,2,6));
}

public static String rec(String s, int n, int m) {
    if(n == 0 /* && missing 2nd part of condition */){
        return s;
    } else {
        if(n>0){
            s = s.substring(1);
            n--;  
        }
        if(/* missing condition */){
            s= s.substring(0, s.length()-1);
        }
        return rec(s,n,m);
    }
}

如果能得到任何帮助，我将不胜感激。

Answer 1

因此，修复递归方法相当容易。我们所做的与您为 n 所做的完全相同：

public static String rec(String s, int n, int m) {        
    if (n == 0 && m == 0) { 
        return s;
    }
    else {
        if(n > 0) {
            s = s.substring(1);
            n--;
        }
        if(m > 0) {
            s = s.substring(0, s.length()-1);
            m--;
        }
        return rec(s,n,m);
    }
}

现在的问题是作为输入给出的m 的值是从字符串的开头测量的，如果它是从字符串的结尾测量的，对我们来说会更方便。

我们可以引入一个新方法来为我们做这件事，它作为我们递归方法的入口点：

public static String substr(String s, int n, int m) {
    final int newM = s.length() - m - 1; //-1 to be inclusive of the char
    return rec(s, n, newM);
}

然后，您可以将 main 方法更改为调用 substr()：

public static void main(String[] args) {
    String s = "substringme";

    System.out.println(substr(s,2,6));
}

当我使用递归方法时，我经常发现自己在编写这类“入口点”方法。如果您正确执行此操作，substr 将是您面向公众的方法，rec 将是私有方法。

Answer 2

我建议您在第一个循环中执行 m--，因为当您从前面缩短 s 时，作为索引的 m 的定义会发生变化。

 public static String rec(String s, int n, int m) {
         if(n == 0 && m == s.length() - 1){
             return s;
         } else {
             if (n > 0) {
                 s = s.substring(1);
                 n--;
                 m--;
             }
             if (m < s.length() - 1) {
                 s = s.substring(0, s.length() - 1);
             }
             return rec(s, n, m);
         }
     }

Answer 3

你可以做的是寻找m和字符串长度之间的差异，并从字符串末尾截掉字符，直到它是正确的长度。

import java.util.*;
public class Test {
    public static void main(String[] args) {
        String s = "substringme";
        System.out.println(rec(s,2,6));
    }

    public static String rec(String s, int n, int m) {
        if(n == 0 && s.length()-m < 1){
            return s;
        } else {

            if(s.length()-m > 1){
                s= s.substring(0, s.length()-1);
            }
            else if(n>0){
                s = s.substring(1);
                n--;  
            }
            return rec(s,n,m);
        }
    }
}

从 2 到 6 的子字符串也不应该是“bstr”，而不是“bstri”？

System.out.println(s.substring(2, 6)); //equals bstr