我有一个二叉搜索树，我认为我的方法之一是工作不正确。我的程序是一个逐字分离从文件中读取的字符串并删除其中的特殊字符的程序，然后按字母顺序将这些单词传输到数据结构中。如果在传输过程中，同一个单词先前被传递，那么它会增加该单词的频率。在检查程序输出时，我看到了这样的情况。
我的输出：

Readed Line: sun-meal            //After some operation it is seperated like "sun" and "metal"
    String inserted.
    String inserted.
Readed Line: sun-oil             //After some operation it is seperated like "sun" and "oil"
    String inserted.
    String inserted.             //Error is here.

真实输出应为：

Readed Line: sun-meal                      //After some operation it is seperated like "sun" and "metal"
    String inserted.
    String inserted.
Readed Line: sun-oil                       //After some operation it is seperated like "sun" and "oil"
    String inserted.
    Repeated String. Frequency +1.         //It should be like that.

我将分享我的源代码，但我想知道的是我做错了什么？为什么要插入两次“sun”？
treedriver类：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class TreeDriver
{
    public static void main(String [] args) throws FileNotFoundException {
        Tree stTree = new Tree();
        TreeNode compareNode;

        Scanner scan = new Scanner(new File(args[0]));

        while (scan.hasNextLine()) {
            String data = scan.nextLine();
            System.out.println("Readed Line: "+data);
            String[] convertedData = data.replaceAll("[^a-zA-Z ]", " ").toLowerCase().split("\\s+");
            int y = 0;
            try {
                while(convertedData[y] != null){
                    String st = convertedData[y];

                    if (st.contains(" ")) {

                    }
                    else{
                        compareNode = Tree.search(stTree.getRoot(), st);

                        if (compareNode != null) {
                            compareNode.upFreq();
                            System.out.println("\tRepeated String. Frequency +1.");
                        } else {
                            stTree.insert(st);
                            System.out.println("\tString inserted.");
                        }
                        y++;
                    }
                }
            }
            catch(Exception ignored) {
            }
        }

        scan.close();
    }
}

树节点类

public class TreeNode
{
    private int freq;   //frequency of the String in the Node
    private String stValue;
    private TreeNode left;
    private TreeNode right;

    public TreeNode(String st)
    {
        stValue = st;
        left = null;
        right = null;
        freq = 1;
    }

    public void add(String st)
    {
        if (left == null)
        {
            left = new TreeNode(st);
        }
        else if (right == null)
        {
            right = new TreeNode(st);
        }
        else
        {
            if(countNodes(left) <= countNodes(right))
            {
                left.add(st);
            }
            else
            {
                right.add(st);
            }
        }
    }

    //Count the nodes in the binary tree to which root points, and
    public static int countNodes( TreeNode root ) {
        if ( root == null )

            // The tree is empty.  It contains no nodes.
            return 0;

        else {

            // Start by counting the root.
            int count = 1;

            // Add the number of nodes in the left subtree.
            count += countNodes(root.getLeft());
            // Add the number of nodes in the right subtree.
            count += countNodes(root.getRight());

            return count;  // Return the total.
        }
    }

    public TreeNode getLeft(){
        return left;
    }

    public TreeNode getRight(){
        return right;
    }

    public String getString()
    {
        return stValue;
    }

    public void upFreq()
    {
        freq = freq + 1;
    }
    public int getFreq()
    {
        return freq;
    }

}

树类：

public class Tree
{
    private TreeNode root;

    public Tree()
    {
        root = null;
    }

    public boolean isEmpty()
    {
        return root == null;
    }

    public void insert(String st)
    {
        if (isEmpty())
        {
            root = new TreeNode(st);
        }
        else
        {
            root.add(st);
        }
    }

    public TreeNode getRoot()
    {
        return root;
    }

    public static TreeNode search(TreeNode root, String st)
    {
        if(root == null)
        {
            return null;
        }
        else if(st.equals(root.getString()))
        {
            return root;
        }
        else
        {   if (root.getLeft() != null)
            return search(root.getLeft(), st);
        else
            return search(root.getRight(), st);
        }
    }
    public TreeNode found(TreeNode root)
    {
        return root;
    }
    public static void preorderPrint(TreeNode root)
    {
        if ( root != null )
        {
            System.out.print( root.getString() + " " );  // Print the root item.
            preorderPrint( root.getLeft() );   // Print items in left subtree.
            preorderPrint( root.getRight() );  // Print items in right subtree.
        }
    }
}

你能帮我找到问题吗？