Question

我使用由main函数读入的文本文件构建了二叉搜索树。生成的树包含文本文件的单词，带有计数，以便不插入相同的单词两次。问题不在于构建树，而在于正确显示信息。数据需要以4列打印，以保持可读性。

示例：

|BTNode1|BTNode2|BTNode3|BTNode4|  
|BTNode5|BTNode6|BTNode7|BTNode8|

BTNode类有一个toString()方法，用于打印出各个节点的数据。但是，每当我使用根节点调用下面的代码，并且计数为0时，我会正确地获得节点信息，但是每列的节点数量非常奇怪。任何想法如何让这个工作？如有必要，我可以发布其他代码。

编辑：添加了整个类以反映更改，并添加了示例当前输出。可能是构建树的问题。

EDIT2：已更改printcount = 1，修复了显示问题。代码现在可以正常运行。

package speech;

public class BSTree {
private BTNode root;
private final String DISPLAY_FORMAT_CAPS =
    "*****************************************************************";
private StringBuilder buffer = new StringBuilder();
private int printcount = 1;
public BSTree (){
    root = null;
}

public BTNode insert(String indata, boolean lowercase){
    if(lowercase){
        if(root != null){
            return insertRecursive(root,indata.toLowerCase());
        }
        else{
            root = new BTNode(indata.toLowerCase());
            return root;
        }
    }
    else{
        if(root != null){
            return insertRecursive(root,indata);
        }
        else{
            root = new BTNode(indata);
            return root;
        }

    }

}

private BTNode insertRecursive(BTNode node, String value) {
    if (value.compareTo(node.data) < 0){
        if (node.left != null) {
            return insertRecursive(node.left, value);
        } else {
            //System.out.println("  Inserted " + value + " to left of Node " + node.data);
            node.left = new BTNode(value);
            return node.left;
        }
    } else if (value.compareTo(node.data) > 0) {
        if (node.right != null) {
            return insertRecursive(node.right, value);
        } else {
            //System.out.println("  Inserted " + value + " to right of Node " + node.data);
            node.right = new BTNode(value);
            return node.left;
        }
    } else if (value.compareTo(node.data) == 0){
        node.incrementCount();
        //System.out.println("Incremented count of " + value + " to: " + node.wordcount);
        return node;
    }
    return null;
}

private int wordcountRecursive(BTNode node){
    if(node == null){
        return 0;
    }
    else{
        return wordcountRecursive(node.left) + node.wordcount + wordcountRecursive(node.right);
    }
}

public int wordcount(){
    return wordcountRecursive(root);
}

public void display(){
    System.out.println(DISPLAY_FORMAT_CAPS);
    displayRecursive(root);
    System.out.println(buffer.toString());
    System.out.println(DISPLAY_FORMAT_CAPS);
    System.out.println("Word Count:" + wordcount());

}


private void displayRecursive (BTNode node){
    //System.out.println(count);
    if(node != null){
        displayRecursive(node.left);
        addNodeDisplay(node);       
        displayRecursive(node.right);

    }

}

private void addNodeDisplay(BTNode node){
    if(printcount % 4 != 0){
        buffer.append("|").append(node);
    }
    else{
        buffer.append("|").append(node).append("|\n");
    }
    printcount++;
}
}

Answer 1

我添加了一些示例数据，看起来很有效：

private void displayRecursive(Node node) {
  displayRecursive(node, 0);
  System.out.println("");
}

private int displayRecursive(Node node, int count) {

  if (node != null) {
    // Do left first.
    count = displayRecursive(node.getLeft(), count);
    // New line?
    if (count > 0 && count % 4 == 0) {
      // End of line.
      System.out.println("|");
    }
    // Then me.
    System.out.print("|" + node);
    count += 1;
    // Then right.
    count = displayRecursive(node.getRight(), count);
  }
  return count;
}

private void test() {
  Node root = new Node("Root");
  Node left = new Node("Left");
  Node right = new Node("Right");
  root.setLeft(left);
  root.setRight(right);
  Node leftLeft = new Node("Left.Left");
  leftLeft.setLeft(new Node("LeftLeftLeft"));
  leftLeft.setRight(new Node("LeftLeftRight"));
  left.setLeft(leftLeft);
  left.setRight(new Node("Left.Right"));
  right.setLeft(new Node("Right.Left"));
  right.setRight(new Node("Right.Right"));
  displayRecursive(root);
}

public static void main(String[] args) throws InterruptedException {
  try {
    Test test = new Test();
    test.test();
  } catch (Exception e) {
    e.printStackTrace();
  }
}

static class Node {
  final String data;
  private Node left = null;
  private Node right = null;

  Node(String data) {
    this.data = data;
  }

  @Override
  public String toString() {
    return data;
  }

  /**
   * @return the left
   */
  public Node getLeft() {
    return left;
  }

  /**
   * @param left the left to set
   */
  public void setLeft(Node left) {
    this.left = left;
  }

  /**
   * @return the right
   */
  public Node getRight() {
    return right;
  }

  /**
   * @param right the right to set
   */
  public void setRight(Node right) {
    this.right = right;
  }
}

打印：

|LeftLeftLeft|Left.Left|LeftLeftRight|Left|
|Left.Right|Root|Right.Left|Right|
|Right.Right

递归遍历二进制搜索树并在列中打印数据

1 个答案: