Construire un arbre binaire en Java
Je construis un arbre binaire. Faites-moi savoir si c'est une bonne façon de le faire. Si non s'il vous plaît dites-moi comment ?? Je ne pouvais pas trouver un lien approprié où la construction d'un arbre binaire général a été codée. Partout BST est codé.
3
/ \
1 4
/ \
2 5
C’est l’arbre binaire que je veux créer. Je devrais être capable de faire toutes les traversées d’arbres.
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;
}
}
Je pense que c'est ce que vous recherchez:
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;
}
}
L'idée derrière un arbre binaire est qu'il est trié. Toutes les valeurs supérieures à la valeur actuelle se trouvent dans le nœud droit et toutes les valeurs inférieures au nœud gauche. Cela signifie que vous ne devriez pas créer l'arbre dans votre programme principal. Au lieu de cela, chaque nœud doit avoir une méthode "insert" qui détermine si le nouveau nœud doit aller à gauche ou à droite du nœud actuel. Lorsque vous avez un nouveau nœud, vous créez ce nœud, puis vous appelez root.insert(newNode).
La méthode par insertion fonctionnerait alors comme ceci (puisqu'il s'agit évidemment d'un travail d'étudiant et que vous êtes censé en tirer des leçons, vous n'obtenez que du pseudo-code de moi, pas de solution complète):
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.
Rechercher si un objet est déjà dans l'arborescence 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 ne voudriez pas apprendre comment les arbres binaires fonctionnent et que vous les utilisiez, utilisez simplement TreeSet qui est une implémentation d'arborescence binaire qui fonctionne déjà.
À mon avis, étant donné que nous ne sommes pas sûrs de l'implémentation de BinaryTree en ce qui concerne certaines méthodes telles que add et traverse, notre meilleur choix est d'en faire une classe abstraite. Je suis presque sûr que ce code est suffisant pour une implémentation générale de Binarytree.
Ce que vous voulez, c'est un exemple de successeur d'un arbre binaire, mais je doute que ce soit un exemple.
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;
}
}
Ce que vous faites semble être un bon point de départ (bien que vous souhaitiez peut-être ajouter une référence au nœud parent si vous envisagez de pouvoir déplacer les nœuds dans l’arborescence ou d’effectuer des traversées inverses).
En fonction de l'utilisation de l'arborescence binaire, vous pouvez simplement utiliser un TreeMap.
Le problème est cependant que nous ne savons pas pour quoi vous utilisez votre arbre binaire, et une grande partie de la complexité de la conception et de la mise en œuvre et des décisions en découlent.