Question

我正在实现一种代码，用于比较Array中的Strings，并使用stringONE.compareTo(stringTwo)返回最小的代码。

该代码将使用递归来遍历Array而不是for循环。

我实现了代码，以便compare方法不断使用不同的参数调用自身，直到到达Array的末尾为止，然后异常处理将退出递归。

问题在于：它一直迭代直到到达堆栈溢出而没有触发outofboundsException。

下面是我的代码，您可以测试：

代码：

public class recursivefindMinimum {
    public static String [] stringArray = {"delta","alpha","omega","zeta"};
    public static String result;

    public static void main (String[]args) {
        System.out.println("result :  "+findMinimum(stringArray, 0, 1));
    }

    public static String findMinimum(String[] stringArray, int index1, int index2) {
        int number = stringArray[index1].compareTo(stringArray[index2]);

        if (number< 0) {
            findMinimum(stringArray,index1,index2++); zebobi="delta1";
        }
        else if (number> 0) {
            findMinimum(stringArray,index2,index2++);zebobi="delta2";
        }
        else if (number== 0) {
            findMinimum(stringArray,index1,index2++);zebobi="delta3";
        }
    } catch(Exception e) {
        System.out.println(index1);
        System.out.println(index2);
        result= stringArray[index1]

        return result;
    }
}

Answer 1

在递归中，您必须始终有一个基本情况，这是您停止递归的点。目前，您有针对每种可能结果的递归案例：

if (number< 0){
     findMinimum(stringArray,index1,index2++); zebobi="delta1";
}
else if (number> 0){
     findMinimum(stringArray,index2,index2++);zebobi="delta2";
}
else if (number== 0){
     findMinimum(stringArray,index1,index2++);zebobi="delta3";
}

（当number小于，大于或等于零时）因此，您的方法将始终在调用自身，这是无限递归。您需要包含一个基本案例，该案例将停止递归

另外，最好将result设为仅在findMinimum()范围内声明的变量。然后，您需要将递归调用更改为result = findMinimum(...)

此问题的基本情况是索引变量之一超出范围时。

public static String findMinimum(String[] stringArray, int index1, int index2) 
{
    String result = "";
    if(index1 > stringArray.length || index2 > stringArray.length-1) {
        return stringArray[index2-1];
    }

    int number = stringArray[index1].compareTo(stringArray[index2]);


    if (number< 0){
        result = findMinimum(stringArray,index1,index2+1); zebobi="delta1";
    }
    else if (number> 0){
        result = findMinimum(stringArray,index2,index2+1);zebobi="delta2";
    }
    else if (number== 0){
        result = findMinimum(stringArray,index1,index2+1);zebobi="delta3";
    }

    return result;
 }

如果您尝试触发异常，然后从异常块返回：

-您需要添加一个try块（如果不尝试，您将无法获得收获）

-您需要通过index2 + 1而不是index2++

-您需要返回stringArray[index2]而不是stringArray[index1]

public static String findMinimum(String[] stringArray, int index1, int index2) 
{
    String result;
    int number = stringArray[index1].compareTo(stringArray[index2]);

    try {
        if (number< 0){
        result = findMinimum(stringArray,index1,index2+1); zebobi="delta1";}

        else if (number> 0){
        result = findMinimum(stringArray,index2,index2+1);zebobi="delta2";}

        else if (number== 0){
        result = findMinimum(stringArray,index1,index2+1);zebobi="delta3";}

    }catch(Exception e){
        System.out.println(index1);
        System.out.println(index2);
        result= stringArray[index2]; 
    }
    return result;
}

输出：

result :  zeta

Answer 2

这是另一种可能避免索引问题的解决方案：

public static String findMinimumRecursive(String[] array, String currentMinString){
  if(array.length == 0)
    return currentMinString;

  return findMinimumRecursive(
              Arrays.copyOfRange(array, 1, array.length), 
              ((Integer)currentMinString.length()).compareTo(array[0].length()) < 0 ? currentMinString : array[0]);
}

然后您可以像下面这样调用此函数：

String[] arr = {"abc", "abcd", "ab", "abe"};
String result = findMinimumRecursive(Arrays.copyOfRange(arr, 1, arr.length), arr[0]);

此函数将使用数组的第一个元素来评估当前的最小长度字符串，并且每次使用被移除的元素和当前的最小字符串时，它将使用相同的数组调用自身。停止条件是输入数组为空，它将仅返回当前的最小长度字符串，该字符串对应于该数组所有字符串的最小长度

呼叫将如下所示：

findMinimumRecursivly（[“ abcd”，“ ab”，“ abe”]，“ abc”）
findMinimumRecursivly（[“ ab”，“ abe”]，“ abc”）
findMinimumRecursivly（[“ abe”]，“ ab”）
findMinimumRecursivly（[“ abe”]，“ a”）
findMinimumRecursivly（[]，“ a”）

请注意，方法Arrays.copyOfRange创建的数组具有与第一个参数相同的元素，但仅从第二个和第三个参数的开始和结束索引开始-请参见https://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html#copyOfRange(T[],%20int,%20int)

比较字符串数组并返回最小的一个

2 个答案: