通过降低二叉搜索树中的字数来打印字计数器

Question

I've created a word counter using a binary search tree. When a word is added more than once, the count of that word increases. My problem lies in the fact that I want to have two toString() functions: one that prints the word and its count in alphabetical order (which I've already figured out), and one that prints the word and its count in descending count order, and if the counts for words are the same, sorted by ascending alphabetical order.

I'm struggling with the second toString() function. I set up a way to compare a node's count values to the count values of the left and right nodes, and to return the count of the largest one. However, I'm getting a few errors, and I'm not sure I'm on the right track here.

Here's my code which includes my Node container class, the Add function, and my working basic toString() function.

public class WordCounter extends BinarySearchTree<String, Integer>
{
  public String word;
  public int size;

  // node container class

  public class Node<String>
  {
    public String data;
    public int count = 1;

    public Node<String> left, right;

    public Node(String data)
    {
      this.data = data;
      left = null;
      right = null;
    }
  }

  private Node<String> root;

  public WordCounter()
  {
    root = null;
    size = 0;
  }

  // add function

  public void Add(String word)
  {
    root = recAdd(root, new Node<String>(word));
  }

  private Node<String> recAdd(Node<String> node, Node<String> newNode)
  {
    // base case - found open slot
    if (node == null)
    {
      return newNode;
    }

    // general case - add to right

    final int comparison = newNode.data.compareTo(node.data);

    if (comparison > 0)
    {
      node.right = recAdd(node.right, newNode);
    }

    // general case - add to left

    else if (comparison < 0)
    {
      node.left = recAdd(node.left, newNode);
    }

    // if word values are the same, increment word count

    else
    {
      node.count++;
    }
    return node;
  }

  // toString() function

  public String toString()
  {
    return recInOrderToString(root);
  }

  private String recInOrderToString(Node<String> node)
  {
    if (node == null)
    {
      return "";
    }

    return recInOrderToString(node.left) + "\n word: " + node.data.toString() + "\t count: " + node.count + recInOrderToString(node.right);
  }

Here's the function I'm struggling with.

   public String toStringByCount()
  {
    return recToStringByCount(root);
  }

  private String recToStringByCount(Node<String, Integer> node)
  {
    // to be thorough in comparisons, I went through every possible case
    // counts are compared first; if any are the same, their data must be compared
    // larger counts are printed first, then ascending alphabetical order for those with the same counts

    // node is null, return empty string
    if (node == null)
      return "";

    // both nodes are null, return current node
    if (node.left == null && node.right == null)
    {
      return "\n word: " + node.data.toString() + "\t count: " + node.count;
    }

    // right node is null, left is not null
    if (node.right == null && node.left != null)
    {
      if (node.count > node.left.count)
      {
        return "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.left);
      } else if (node.count < node.left.count)
      {
        return recToStringByCount(node.left) + "\n word: " + node.data.toString() + "\t count: " + node.count;
      } else if (node.count == node.left.count)
      {
        if (node.data.compareTo(node.left.data) < 0)
        {
          return recToStringByCount(node.left) + "\n word: " + node.data.toString() + "\t count: " + node.count;
        } else if (node.data.compareTo(node.left.data) > 0) {
          return "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.left);
        }
      }
    }

    //left node is null, right is not null
    if (node.left == null && node.right != null)
    {
      if (node.count > node.right.count)
      {
        return "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.right);
      } else if (node.count < node.right.count)
      {
        return recToStringByCount(node.right) + "\n word: " + node.data.toString() + "\t count: " + node.count;
      } else if (node.count == node.right.count)
      {
        if (node.data.compareTo(node.right.data) < 0)
        {
          return recToStringByCount(node.right) + "\n word: " + node.data.toString() + "\t count: " + node.count;
        } else if (node.data.compareTo(node.right.data) > 0) {
          return "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.right);
        }
      }
    }

    // both nodes are valid
    if ((node.left != null) && (node.right != null))
    {
      // counts are the same
      if ((node.count == node.left.count) && (node.count == node.right.count))
      {
        // must compare data

        // data is greater than left and right
        if ((node.data.compareTo(node.left.data) > 0) && (node.data.compareTo(node.right.data) > 0))
        {
          if (node.left.data.compareTo(node.right.data) > 0)
          {
            return "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.left) + recToStringByCount(node.right);
          } else if (node.left.data.compareTo(node.right.data) < 0) {
            return "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.right) + recToStringByCount(node.left);
          }
        }

        // data is less than left and right
        else if ((node.data.compareTo(node.left.data) < 0) && (node.data.compareTo(node.right.data) < 0))
        {
          if (node.left.data.compareTo(node.right.data) > 0)
          {
            return recToStringByCount(node.left) + recToStringByCount(node.right) + "\n word: " + node.data.toString() + "\t count: " + node.count;
          } else if (node.left.data.compareTo(node.right.data) < 0) {
            return recToStringByCount(node.right) + recToStringByCount(node.left) + "\n word: " + node.data.toString() + "\t count: " + node.count;
          }
        }

        // data is less than left, greater than right
        else if ((node.data.compareTo(node.left.data) < 0) && (node.data.compareTo(node.right.data) > 0))
        {
          return recToStringByCount(node.left) + "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.right);
        }

        // data is greater than left, less than right
        else if ((node.data.compareTo(node.left.data) > 0) && (node.data.compareTo(node.right.data) < 0))
        {
          return recToStringByCount(node.right) + "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.left);
        }
      }

      // left is same, smaller than right
      else if ((node.count == node.left.count) && (node.count < node.right.count))
      {
        // must compare data

        // data greater than left
        if (node.data.compareTo(node.left.data) > 0)
        {
          return recToStringByCount(node.right) + "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.left);
        }

        // data smaller than left
        else if (node.data.compareTo(node.left.data) < 0)
        {
          return recToStringByCount(node.right) + recToStringByCount(node.left) + "\n word: " + node.data.toString() + "\t count: " + node.count;
        }
      }

      // left is same, greater than right
      else if ((node.count == node.left.count) && (node.count > node.right.count))
      {
        // must compare data

        // data greater than left
        if (node.data.compareTo(node.left.data) > 0)
        {
          return "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.left) + recToStringByCount(node.right);
        }

        // data smaller than left
        else if (node.data.compareTo(node.left.data) < 0)
        {
          return recToStringByCount(node.left) + "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.right);
        }
      }

      // right is same, smaller than left
      else if ((node.count == node.right.count) && (node.count < node.left.count))
      {
        // must check data

        // data greater than right
        if (node.data.compareTo(node.right.data) > 0)
        {
          return recToStringByCount(node.left) + "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.right);
        }

        // data smaller than right
        else if (node.data.compareTo(node.right.data) < 0)
        {
          return recToStringByCount(node.left) + recToStringByCount(node.right) + "\n word: " + node.data.toString() + "\t count: " + node.count;
        }
      }

      // right is same, greater than left
      else if ((node.count == node.right.count) && (node.count > node.right.count))
      {
        // must compare data

        // data greater than right
        if (node.data.compareTo(node.right.data) > 0)
        {
          return "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.right) + recToStringByCount(node.left);
        }

        // data smaller than right
        else if (node.data.compareTo(node.right.data) < 0)
        {
          return recToStringByCount(node.right) + "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.left);
        }
      }

      // greater than right & left
      else if ((node.count > node.left.count) && (node.count > node.right.count))
      {
        // must compare right & left count

        // right greater than left
        if (node.right.count > node.left.count)
        {
          return "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.right) + recToStringByCount(node.left);
        }

        // right smaller than left
        else if (node.right.count < node.left.count)
        {
          return "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.left) + recToStringByCount(node.right);
        }

        // right equal to left
        else if (node.right.count == node.left.count)
        {
          // must compare data

          if (node.right.data.compareTo(node.left.data) > 0)
          {
            return "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.right) + recToStringByCount(node.left);
          } else if (node.right.data.compareTo(node.left.data) < 0) {
            return "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.left) + recToStringByCount(node.right);
          }
        }
      }

      // less than right & left
      else if ((node.count < node.left.count) && (node.count < node.right.count))
      {
        // must compare right & left counts

        // right greater than left
        if (node.right.count > node.left.count)
        {
          return recToStringByCount(node.right) + recToStringByCount(node.left) + "\n word: " + node.data.toString() + "\t count: " + node.count;
        }

        // right less than left
        if (node.right.count < node.left.count)
        {
          return  recToStringByCount(node.left) + recToStringByCount(node.right) + "\n word: " + node.data.toString() + "\t count: " + node.count;
        }

        // right equal to left
        if (node.right.count == node.left.count)
        {
          // must compare data

          if (node.right.data.compareTo(node.left.data) > 0)
          {
            return recToStringByCount(node.right) + recToStringByCount(node.left) + "\n word: " + node.data.toString() + "\t count: " + node.count;
          } else if (node.right.data.compareTo(node.left.data) < 0) {
            return recToStringByCount(node.left) + recToStringByCount(node.right) + "\n word: " + node.data.toString() + "\t count: " + node.count;
          }
        }
      }

      // greater than left, less than right
      else if ((node.count > node.left.count) && (node.count < node.right.count))
      {
        return recToStringByCount(node.right) + "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.left);
      }

      // smaller than left, greater than right
      else if ((node.count < node.left.count) && (node.count > node.right.count))
      {
        return recToStringByCount(node.left) + "\n word: " + node.data.toString() + "\t count: " + node.count + recToStringByCount(node.right);
      }
    }
    return "";
  }

Like I said, not sure I'm approaching this correctly. I'm also getting errors for "int cannot be dereferenced" on compareCountLeft and compareCountRight, and "int cannot be converted to String" on my return statements.

Answer 1

Some problems:
1. you need to test node.left and node.right aren't null before using the compareTo function
2. You are returning integer instead of string. you are missing the return of the data itself:

private String recToStringByCount(Node<String> node) {
  if (node == null)
    return "";
  if (node.left == null && node.right == null) 
    return "\n word: " + node.data.toString() + "\t count: " + node.count;

3. your if statements doesn't cover all the cases, so you don't have a return statement for each possible outcome, therefore the function won't run
4. you are missing the recursive call to itself. in the if statements instead of returning count, you should do something like your first toString:

return recToStringByCount(node.left) + recToStringByCount(node) + recToStringByCount(node.right);