学习二叉树，无法弄清楚如何合并 2 个代码示例

Question

如何添加/组合此二进制树：

import java.util.Scanner;
public class BinaryTreeTest {
  public static void main(String[] args) {
    new BinaryTreeTest().run();
  }
  // Node Class
  static class Node {
    Node left;
    Node right;
    int value;
    public Node(int value) {
      this.value = value;
    }
  }
  public void run() {
    // build simple tree 
    Node root = new Node(5);
    System.out.println("Binary Tree Example");
    System.out.println("Building tree with root value of ID " + root.value);
    insert(root, 1);
    insert(root, 8);
    insert(root, 6);
    insert(root, 3);
    insert(root, 9);
    System.out.println("Traversing tree in order");
    printInOrder(root);
    System.out.println("Traversing tree front-to-back from location 7");
    printFrontToBack(root, 7);
  }
  public void insert(Node node, int value) {
    if (value < node.value) {
      if (node.left != null) {
        insert(node.left, value);
      } else {
        System.out.println("  Inserted " + value + " to left of "
            + node.value);
        node.left = new Node(value);
      }
    } else if (value > node.value) {
      if (node.right != null) {
        insert(node.right, value);
      } else {
        System.out.println("  Inserted " + value + " to right of "
            + node.value);
        node.right = new Node(value);
      }
    }
  }
  public void printInOrder(Node node) {
    if (node != null) {
      printInOrder(node.left);
      System.out.println("  Traversed " + node.value);
      printInOrder(node.right);
    }
  }
  /**
   * uses in-order traversal when the origin is less than the node's value
   * 
   * uses reverse-order traversal when the origin is greater than the node's
   * order
   */
  public void printFrontToBack(Node node, int id) {
    if (node == null)
      return;
    if (node.value > id) {
      // print in order
      printFrontToBack(node.left, id);
      System.out.println("  Traversed " + node.value);
      printFrontToBack(node.right, id);
    } else if (node.value < id) {
      // print reverse order
      printFrontToBack(node.right, id);
      System.out.println("  Traversed " + node.value);
      printFrontToBack(node.left, id);
    } else {
      // order doesn't matter
      printFrontToBack(node.left, id);
      printFrontToBack(node.right, id);
    }
  }
}

有了这段代码，我就可以在创建的二进制树中插入Person实例：

import java.util.Scanner;
class clubmember {
    public static void main(String[] args) {
        int id;
        String fname, lname;
        Scanner input = new Scanner(System.in);
        System.out.println("ID>");
        id = input.nextInt();
        System.out.println("Fname >");
        fname = input.next();
        System.out.println("lname >");
        lname = input.next();

        Person object1 = new Person(id, fname, lname);
        System.out.println(object1);

    }
}

public class Person {
    private final int id;
    private final String firstName;
    private final String lastName;

    public Person(int id, String firstName, String lastName) {
        this.id = id;
        this.firstName = firstName;
        this.lastName = lastName;
    }
    public int getId() {
        return id;
    }
    public String getFirstName() {
        return firstName;
    }
    public String getLastName() {
        return lastName;
    }
    @Override
    public String toString() {
        return String.valueOf(id) + ": " + firstName + " " + lastName;
    }
}

Answer 1

这是一个糟糕的抽象-难怪你在合并它时遇到困难。我建议在某个地方使用BinaryTree类，最好是使用泛型的类：

public class BinaryTree<T> {
    // What methods do all BinaryTrees need?
}

与现有数据结构相比，您将更容易集成此数据结构。

也许这可以让你开始。

Answer 2

一般情况下创建二叉树

创建一个名为BinaryTree的类会更容易，也会创建更干净的代码，它将是这样的）：

class Node
{
   Node left, right;
   Person value;
   public Node(Person val)  {
     value = val;
   }
}
public class BinaryTree {
   Node head;    
   public BinaryTree() {
      head = null;
   }
   public void insert(Person data) {
       Node tmp = new Node(data);
       if (head == null) head = tmp;
       else
          // do comparisons with head to decide where to add the new node
         head->left = new Node(data);
         // or head->right = new Node(data);
   }
   public void traverse() {
     // could be similar to your printInOrder method
   }
}

然后你可以做：

... main(String[] args) {
   BinaryTree tree = new BinaryTree();
   tree.insert(new Person(...));
   tree.insert(new Person(...));
   tree.traverse();
}

使您的代码在不做太多更改的情况下工作

这是关于如何在已经创建的代码中"工作"的更多内容。

如果您想在二叉树中插入Person实例，首先您应该更改：

  // Node Class
  static class Node {
    Node left, right;
    int value;
    public Node(int value) {
      this.value = value;
    }
  }

不采用int值，而是采用Person实例，如下所示：

  // Node Class
  static class Node {
    Node left, right;
    Person per;
    public Node(Person per) {
      this.per = per;
    }
  }

您还应该更改insert方法以获取Person实例，而不是int值。并将比较(value < node.value)更改为比较Person实例，可能是通过它们的lastName或id。

然后在你的clubmember main代码中，你可以做：

public static void main(String[] args) {
   BinaryTreeTest foo;    

   Person per1 = new Person(...);
   BinaryTreeTest.Node nod1 = new BinaryTreeTest.Node(per1);
   Person per2 = new Person(...);
   foo.insert(nod1, per2);