Question

这个让我头晕目眩。就在我想到的时候，我意识到有些事情是不对的。我必须使用递归进行此分配。任何提示？

/**
 * Uses recursion to find index of the shortest string.
 * Null strings are treated as infinitely long.
 * Implementation notes:
 * The base case if lo == hi.
 * Use safeStringLength(paths[xxx]) to determine the string length.
 * Invoke recursion to test the remaining paths (lo +1)
 */
static int findShortestString(String[] paths, int lo, int hi) {
    int min=lo;
    if (lo==hi)
        return min;
    if (safeStringLength(paths[lo]) < safeStringLength(paths[lo+1])){
        min=lo;
        return Math.min(min, findShortestString(paths, lo+1, hi));
    }
    else{
        min=lo+1;
        return Math.min(min, findShortestString(paths, lo+1, hi));
    }
}

Answer 1

我觉得有点意思：

static int findShortestString(String[] paths, int lo, int hi) 
{
    if (lo==hi)
        return lo;

    int ShortestIndexSoFar = findShortestString(paths, lo+1, hi);
    if(safeStringLength(paths[ShortestIndexSoFar]) < safeStringLength(paths[lo]))
        return ShortestIndexSoFar;
    else
        return lo;
}  

static int safeStringLength(String str)
{
    if(str == null)
        return Integer.MAX_VALUE;
    return str.length();
}

解释其工作原理：
这是一个示例：

[0] ab
[1] abcd
[2] a
[3] abc
[4] ab

显然，指数2是最短的认为自下而上。从底部开始向上阅读以下内容我听起来好像每个函数都在链中的上面的函数说话每一行都由传递的函数参数引导。

"[0] ab   (paths, 0, 4): return 2, coz he's shorter than me or anyone before us"
"[1] abcd (paths, 1, 4): return 2, coz he's shorter than me or anyone before us"
"[2] a    (paths, 2, 4): return 2, I'm shorter than anyone before me"
"[3] abc  (paths, 3, 4): return 4, coz he's shorter than me or anyone before us"
"[4] ab   (paths, 4, 4): return 4, I'm the shortest; I don't know any better"

所以在代码中，你会看到确实发生了。
当我们定义ShortestIndexSoFar时，这是每个函数将知道超出它的所有路径中最短的位置在它之后，函数本身检查其索引的路径是否短于下面所有索引中的最短路径继续向上冲最短的一个，最后的人将返回最短的索引。

这有道理吗？

Answer 2

由于这是家庭作业，这里有一个提示可以帮助你学习：

findShortestString方法的签名表明您应该使用二进制搜索。我为什么这么说？为什么这样做是个好主意？所有其他解决方案都遇到了Java中的实际问题......那会是什么？

对OP以外的人...请不要放弃答案......例如通过纠正你的答案！

Answer 3

为什么不直接获取每个元素的长度并对返回的长度进行排序以获得排序？像这样。

int[] intArray = {10, 17, 8, 99, 1}; // length of each element of string array
Arrays.sort(intArray);

Answer 4

一个解决方案将是这样的

public static final int findShortestString(final String[] arr, final int index, final int minIndex) {

    if(index >= arr.length - 1 ) {
        return minIndex;
    }

    if(-1 == safeStringLength(arr[index])) { 
        return index;
    }


    int currentMinIncex = minIndex;

    if(safeStringLength(arr[minIndex]) > safeStringLength(arr[index+1])){
        currentMinIncex = index + 1;
    }


    return findShortestString(arr, index + 1, currentMinIncex);

}



public static final int safeStringLength(final String string) {

    if( null == string) return -1;

    return string.length();

}

Answer 5

一个简单的解决方案：

/**
     * Uses recursion to find index of the shortest string.
     * Null strings are treated as infinitely long.
     * Implementation notes:
     * The base case if lo == hi.
     * Use safeStringLength(paths[xxx]) to determine the string length.
     * Invoke recursion to test the remaining paths (lo +1)
     */
static int findShortestString(String[] paths, int lo, int hi) {
    if (lo==hi)
        return lo;
    if (paths[lo] == null)
       return findShortestString(paths, lo+1, hi);
    int bestIndex = findShortestString(paths, lo+1, hi);
       if (safeStringLength[lo] < safeStringLength[bestIndex])
           return lo;
    return bestIndex;
}

Answer 6

对运行min的结果计算findShortestString没有意义。启动这类问题的最好方法是只考虑一个递归步骤，你可以通过考虑只有两个字符串数组进行比较的情况来做到这一点。

您要做的是检查第一个字符串的长度与第二个字符串的长度。但真正的诀窍在于，您希望通过递归调用函数来测试第二个长度。这很直接，但需要确定递归的结束情况。你成功地做到了这一点，就在lo == hi时。也就是说，当lo == hi最短的已知字符串为lo时（它是唯一已知的字符串！）。

好的，回过头来比较两个字符串。鉴于您知道要比较paths中存储的两个字符串的长度，您可能会执行类似这样的操作（没有递归）：

if(safeStringLength(paths[0]) < safeStringLength(paths[1])){
    return 0; // paths[0] is shorter
}else{
    return 1; // paths[1] is shorter
}

但是你想要递归 - 在递归步骤中你需要以某种方式生成1 paths[1]。我们已经知道如何执行此操作，在lo == hi时，我们返回lo。因此，递归步骤是“将当前最低已知字符串长度与最佳已知索引的字符串长度进行比较” - 等等，我们有一个函数！它是findShortestString。因此，我们可以修改上面写的内容，使其更加简洁，并在基本情况下添加以获得：

static int findShortestString(String[] paths, int lo, int hi) {
    // base case, no comparisons, the only known string is the shortest one
    if(lo == hi){
        return lo;
    }

    int bestIndex = findShortestString(paths, lo+1, hi);
    return safeStringLength(paths[lo]) < safeStringLength(paths[bestIndex]) ? 
        lo : bestIndex;
}

Answer 7

static int findShortestString(String[] paths, int lo, int hi)
{  
  if (lo==hi)  
    return lo;  
  int ShortestIndexDown = findShortestString(paths, lo, (hi + lo)/2);
  int ShortestIndexUp = findShortestString(paths, (lo+hi)/2+1, hi);
  return SafeStringLength(paths[ShortestIndexDown]) < SafeStringLength(paths[ShortestIndexUp])?ShortestIndexDown:ShortestIndexUp;
}

static int safeStringLength(String str)
{
  if(str == null)
    return Integer.MAX_VALUE;
  return str.length();
}

查找最小值出现的数组的索引

7 个答案: