1

所以我需要递归地找到最长的单词，我已经编写了代码，但它不起作用，我不知道要修复什么。

        public static String longestWord(String sentence)
{
    int i = sentence.indexOf(" ");

    if (i==-1){
        return sentence;
    }

    else{
        String first = sentence.substring(0,i);
        String rest = sentence.substring(i+1);

            if(first.length()>=rest.length()){
                return longestWord(first);
            }
        else{
            return longestWord(rest);

        }

    }
}
4

5 回答 5

2

该行：

if(first.length() >= rest.length())

应如下所示：

String res = longestWord(rest);
if(first.length() >= res.length())
于 2012-04-12T00:26:25.990 回答
1

它不起作用的原因是您忽略了longestWord(rest): 的长度，而不是比较初始单词的长度和句子的其余部分，您应该将初始单词的长度与找到的最长单词的长度进行比较句子的其余部分。

String first = sentence.substring(0,i);
String rest = longestWord(sentence.substring(i+1));
return first.length()>=rest.length() ? first : rest;
于 2012-04-12T00:27:38.017 回答
1

您的基本方法是理智的：您将输入分成两个：第一个单词和字符串的其余部分。但是后来逻辑有点混乱。

如果第一个单词比整个字符串的其余部分长，你应该只 return first，而不是longestWord(first)（尽管你确实处理了这种情况：longestWord会注意到这个词不能被拆分并只返回它。虽然它没有意义）。

其次，如果不是这样，你不能假设第一个词不是最长的词。您必须捕获 的返回值longestWord(rest)，然后将该单词的长度与 的长度进行比较first。如果该词更长，则返回它。否则返回 first。

递归“分而治之”的本质是你解决一些较小版本的问题，然后整合这些结果。不要忘记第二部分。这不是一个二叉搜索树搜索，其中数据被组织起来，这样您就可以递归到一半空间或另一半空间来找到答案。你不知道最长的单词可能在哪里。

于 2012-04-12T00:27:55.770 回答
1 
package com.kota.java;
import java.util.*;

class LongestWord{
    String str = "Ram is intelligent boy";
    String stringArray[] = str.split("\\s");

    public String compare(String st1, String st2) {
        if (st1.length() > st2.length()) {
            return st1;
        } else {
            return st2;
        }
    }

    LongestWord() {
        String word = "";
        for (int i = 0; i < stringArray.length; i++) {
            if (i == 0) {
                word = stringArray[0];
            }
            word = compare(word, stringArray[i]);
        }
        System.out.println("Longest word = " + word);
    }

    public static void main(String[] args) {
        new LongestWord();
    }
}
/**
 * Out put : Longest word = intelligent
 * 
 * */
于 2012-07-24T19:57:31.177 回答
1

这是解决问题的另一种方法：

public static String longestWord(String sentence) {
    return longest(sentence.split("\\s+"), 0, 0);
}

private static String longest(String[] words, int idx, int longest) {
    if (idx == words.length)
        return words[longest];
    return longest(words, idx+1,
        words[idx].length() > words[longest].length() ? idx : longest);
}

首先，在longestWord()句子中被空格分割，产生一个单词数组。从那时起，该方法longest()递归地遍历所有通过参数中迄今为止找到的最长的索引的单词longest，直到没有更多的单词。这是一个有效的答案，因为它不会在每一步都创建子字符串。

于 2012-04-12T00:42:07.030 回答