Construire un arbre binaire en Java

Je suis de la construction d'un arbre binaire. Permettez-moi de savoir si c'est une bonne façon de le faire. Si non, merci de me dire comment?? Je ne pouvais pas trouver un lien où la construction d'un général de l'arbre binaire a été codée. Partout BST est codé.

  3
 / \
1   4
   / \
  2   5

C'est l'arbre binaire qui je veux faire.Je devrais être capable de faire tous les arbres traversals.Des choses simples.

public class Binarytreenode
{
    public Binarytreenode left;
    public Binarytreenode right;
    public int data;

    public Binarytreenode(int data)
    {
        this.data=data;
    }

    public void printNode()
    {
        System.out.println(data);
    }

    public static void main(String ar[])
    {
        Binarytreenode root = new Binarytreenode(3);
        Binarytreenode n1 = new Binarytreenode(1);
        Binarytreenode n2 = new Binarytreenode(4);
        Binarytreenode n3 = new Binarytreenode(2);
        Binarytreenode n4 = new Binarytreenode(5);

        root.left = n1;
        root.right = n2;
        root.right.left = n3;
        root.right.right = n4;
    }
}

source d'informationauteur VIN

  1. 13

    Je pense que c'est ce que vous cherchez:

    public class Binarytree
{
private static Node root;
public Binarytree(int data)
{
root = new Node(data);
}
public void add(Node parent, Node child, String orientation)
{
if (orientation.equals("left"))
{
parent.setLeft(child);
}
else
{
parent.setRight(child);
}
}
public static void main(String args[])
{
Node n1 = new Node(1);
Node n2 = new Node(4);
Node n3 = new Node(2);
Node n4 = new Node(5);
Binarytree tree = new Binarytree(3); // 3
tree.add(root, n1, "left"); //        1/\
tree.add(root, n2, "right"); //           4
tree.add(n2, n3, "left"); //            2/\
tree.add(n2, n4, "right"); //               5
}
}
class Node {
private int key;
private Node left;
private Node right;
Node (int key) {
this.key = key;
right = null;
left = null;
}
public void setKey(int key) {
this.key = key;
}
public int getKey() {
return key;
}
public void setLeft(Node left) {
this.left = left;
}
public Node getLeft() {
return left;
}
public void setRight(Node right ) {
this.right = right;
}
public Node getRight() {
return right;
}
}
  2. 6

    L'idée derrière un arbre binaire est qu'elle est triée. Toutes les valeurs supérieures à la valeur actuelle sont dans le droit nœud et chaque valeur plus petite est dans le nœud de gauche. Cela signifie que vous ne devriez pas faire l'arbre de construction de dans votre programme principal. Plutôt, chaque nœud doit avoir un "insérer" une méthode qui détermine si le nouveau nœud doit aller vers la gauche ou la droite du nœud actuel. Lorsque vous avez un nouveau nœud, vous créez ce nœud, puis vous appelez root.insert(newNode).

    L'insert, la méthode serait alors de travailler comme ça (parce que c'est évidemment un étudiant de cession et vous êtes censé apprendre de cela, vous obtenez seulement un pseudo-code de moi, il n'y a pas de solution):

    When value is smaller than own value:
When there already is a left-node:
call left-node.insert(new-node)
When there isn't a left-node yet:
the left-node is now the new-node
When value is larger than own value:
When there already is a right-node:
call right-node.insert(new-node)
When there isn't a right-node yet:
the right-node is now the new-node
When value is equal to own value:
Duplicate value. Either ignore the value or throw an exception.

    Trouver si un objet est déjà dans l'arbre fonctionne de la même manière:

    When requested value is equal to the value of this node
return this node
When the requested value is smaller
When a left node exists
call left.find(value)         
When no left node exists
value doesn't exist in this tree
When the requested value is larger
When a right node exists
call right.find(value)         
When no right node exists
value doesn't exist in this tree

    Dans le cas où vous n'avez pas vraiment envie de savoir comment les arbres binaires de travail et de les utiliser, il suffit d'utiliser TreeSet qui est déjà binaire travail-l'arbre de la mise en œuvre.

  3. 2

    Dans mon opinion, car nous ne sommes pas sûr de ce que la mise en œuvre de la BinaryTree est quand il s'agit de certaines méthodes telles que l'ajout et le traverse, notre meilleur pari est de faire une classe abstraite. Im assez sûr que ce code est suffisant pour un général Binarytree mise en œuvre.

    Ce que vous voulez est une instance d'un successeur d'un Arbre Binaire, mais je doute de son une instance. 

    public abstract class Binarytree
{
private Node root;
public Binarytreenode(int data)
{
root = new Node(data);
}
public abstract void add(int key);
public abstract void traverse();
}
class Node {
private int key;
private Node left;
private Node right;
Node (int key) {
this.key = key;
right = null;
left = null;
}
public void setKey(int key) {
this.key = key;
}
public int getKey() {
return key;
}
public void setLeft(Node left) {
this.left = left;
}
public Node getLeft() {
return left;
}
public void setRight(Node right ) {
this.right = right;
}
public Node getRight() {
return right;
}
}
  4. 0

    Ce que vous faites a l'air bien comme un point de départ (bien que vous voudrez peut-être ajouter une référence au nœud parent si vous prévoyez d'être en mesure de déplacer des nœuds dans l'arbre ou de faire la traversals).

    Selon ce que vous êtes en utilisant de l'arbre binaire pour bien que vous pouvez simplement utiliser un TreeMap.

    Le problème, c'est que nous ne savons pas ce que vous êtes à l'aide de votre Arbre Binaire, et beaucoup de la conception et de la mise en œuvre des complexités et des décisions de la tige.