Question

我对Java有点新，对递归和二叉树来说也很新。我正在构建一个程序，它从文档中获取文本并将其存储在二叉树中。然后我需要一个字符串，找出它出现在文本中的次数。

我的问题是在我添加数据时和/或我在搜索字符串的数据时。

我决定在构建时将每个节点中的字符串和频率存储起来。所以我的添加方法如下：

public void add(String newWord) {

    //Change the word case to make comparing easier
    newWord = newWord.toUpperCase();


    root = recursiveAdd(root, newWord);
}

/**
 * Takes the root and recurses until the root is null (base case)
 * Frequency is incremented if the data is being added, or if
 * it already exits. If the data is not present, the method recurses
 */
private Node recursiveAdd(Node subTree, String newWord) {

    //Base case: the root is null
    //Empty trees have a node created, set, and incr freq
    if (subTree == null) {  
        subTree = new Node();
        subTree.setStoredWord(newWord);
        subTree.incrFreqCount(); 
        return subTree;

    }


    int comparison = newWord.compareTo(subTree.getStoredWord());

    //For a word already in tree, increment the frequency
    if (comparison == 0) {

        if(newWord.equalsIgnoreCase("translyvania"))
        System.out.println("Entered same word incrementation");

        subTree.incrFreqCount();
        return subTree;

        //The root comes before the new word, then 
        //move on to the right child
    } else if(comparison < 0) {

        subTree.setLchild(recursiveAdd(subTree.getLchild(), newWord));

    } else { //if(comparison > 0) {

        subTree.setRchild(recursiveAdd(subTree.getRchild(), newWord));

    }
    return subTree;
}

我似乎无法分辨出我的问题所在。对于我正在搜索的单词，有时它会说它出现16次（我应该得到的），有时它会说1次。它看起来似乎没有一致，价值变化似乎没有理由（虽然我知道必须有一个）。

一旦我的树被构建，我就会拿出我正在搜索的字符串，并通过这些方法传递它。

public void wordSearch(String lookForWord){

    lookForWord = lookForWord.toUpperCase();
    wordSearchRecur(root, lookForWord);

}



private boolean wordSearchRecur(Node subTree, String lookForWord){

    //Base case
    // The root is that same as the string
    if(subTree == null){
        System.out.println("The word \"" + lookForWord + "\" is not "
                + "found in the text");
        return false;
    }

    int comparison = lookForWord.compareTo(subTree.getStoredWord());

    if(comparison == 0){
        System.out.println("The word \"" + lookForWord + "\" is found " + 
                subTree.getFreqCount() + " times in the text");
        return true;


        //Alphabetically before, then move to left branch
    } else if (comparison < 0){

        System.out.println("move to left");
        return wordSearchRecur(subTree.getLchild(), lookForWord);

        //Alphabetically after, then move to right branch
    } else { // if(comparison > 0){
        System.out.println("move to right");
        return wordSearchRecur(subTree.getRchild(), lookForWord);
    }   

}

我也无法理解为什么我要到达wordSearchRecur（）方法的末尾。我不应该在它到达那一点之前回来吗？我的输出显示它已经多次到达那里。

我知道我错过了这些概念的大部分内容，但查看以前的所有帖子并没有帮助。我必须花费3个小时才能在Stack上寻找答案，更不用说所有其他网站了。

请帮忙！

编辑：由于@Joop Eggen的帮助，我编辑了代码以包含我已经改变的内容我现在已经在recursiveAdd（）期间正确计算了频率，但是在wordSearchRecur（）期间，频率似乎不在节点之后。即使比较== 0，freqCount仍为1.

解决：在@Joop Eggen的帮助之后，进一步的问题只是疏忽造成的。谢谢你的帮助。

Answer 1

您将从首先将代码缩减为最简单的形式中获益。

public void add(String word) {

    //Change the word case to make comparing easier
    word = word.toUpperCase();

    root = recursiveAdd(root, word);
}

/**
 * Takes a sub-tree and recurses until the sub-tree is null (base case)
 * Frequency is incremented if the data is being added, or if
 * it already exists. If the data is not present, the method recurses
 */
private Node recursiveAdd(Node subtree, String word) {

    // Base case: the subtree is null
    if (subtree == null) {
        Node node = new Node();
        node.setStoredWord(word);
        node.incrFreqCount();
        return node;
    }

    int comparison = word.compareTo(subtree.getStoredWord());
    if (comparison == 0) {
        // For data already in tree, increment the frequency
        subtree.incrFreqCount();
    } else if (comparison  < 0) {
        subtree.setLchild(recursiveAdd(subtree.getLchild(), word);
    } else /*if (comparison > 0)*/ {
        subtree.setRchild(recursiveAdd(subtree.getRchild(), word);
    }
    return subtree;
}

同时搜索：

public void wordSearch(String lookedForWord){   
    lookedForWord = lookedForWord.toUpperCase();
    wordSearchRecur(root, lookedForWord);
}

private boolean wordSearchRecur(Node subtree, String word){

    if (subtree == null) {
        System.out.println("The word \"" + word + "\" is not "
                + "found in the text");
        return false;
    }

    int comparison = word.compareTo(root.getStoredWord();
    if (comparison == 0){
        System.out.println("The word \"" + word + "\" is found " + 
                subtree.getFreqCount() + " times in the text");
        return true;
    } else if (comparison < 0) {
        return wordSearchRecur(subtree.getLchild(), word);
    } else /*if (comparison > 0)*/ {
        wordSearchRecur(subtree.getRchild(), word);
    }   
}

这有助于防止错误，因为检查/出错的次数较少。

正如你在两种情况下toUpperCase所做的那样，并且在重写中也进行了相同的比较（你有等于并转过compareTo个参数，一切都应该有效。

事实上，显示的代码看起来很不错。做一个递归dumpTree(Node subtree, String indentation)。并检查每一步。

可能你在这里编辑了一些代码，原来一些大括号{ }被错放了。

Java帮助递归＆amp;二叉树

1 个答案: