Implémentation d'un arbre binaire en java

Alors explique mieux comment fonctionne ta matrice, parce que je ne comprends pas à quoi correspondent ses valeurs, surtout vu l'arbre qui est donné en exemple.

Normalement, un arbre binaire représenté avec une matrice d'adjacence ne devrait pas avoir plus de deux valeurs par ligne (deux enfants maximum) et une valeur par colonne (un parent maximum).

Pour l'arbre de ton exemple, la matrice d'adjacence devrait être comme ceci :

  0 1 2 3
0   1   1
1     1
2
3

Ça n'a rien à voir avec la matrice de ton exemple.

Pour moi cette matrice ne correspond toujours à rien, d'autant que tu ne te sers que de la première ligne...

Voici un exemple d'arbre binaire :

public class Tree<D, E extends Comparable<E>> {
    private Node<D, E> root;

    public Tree(){
        root = null;
    }

    public void add(final D description, final E value) {
        if (root == null) {
            root = new Node<>(description, value);
        } else {
            root.add(description, value);
        }
    }

    @Override
    public String toString(){
        return String.valueOf(root);
    }

    private static class Node<D, V extends Comparable<V>> {
        private final D description;
        private final V value;
        private Node<D, V> left;
        private Node<D, V> right;

        public Node(final D description, final V value) {
            this.description = description;
            this.value = value;
            this.left = null;
            this.right = null;
        }

        public boolean add(final D newDescription, final V newValue) {
            final int direction = newValue.compareTo(value);
            if (direction < 0) {
                if (left == null) {
                    left = new Node<>(newDescription, newValue);
                    return true;
                } else {
                    return left.add(newDescription, newValue);
                }
            }
            if (direction > 0) {
                if (right == null) {
                    right = new Node<>(newDescription, newValue);
                    return true;
                } else {
                    return right.add(newDescription, newValue);
                }
            }
            return false;
        }

        @Override
        public String toString(){
            return (left == null ? "" : "{" + left + "} <- ") + "(" + description + "=" + value + ")" + (right == null ? "" : " -> {" + right + "}");
        }
    }
}

Si je reprends ton arbre d'exemple ça pourrait donner ce code de test :

public class Test {
    public static void main(final String[] args) {
        final Tree<String, Integer> tree = new Tree<>();
        tree.add("A", 3);
        tree.add("B", 4);
        tree.add("C", 1);
        tree.add("D", 2);
        System.out.println(tree);
    }
}

L'affichage donne

{(C=1) -> {(D=2)}} <- (A=3) -> {(B=4)}

(avec 1, 2, 3, et 4 dans l'ordre).
Ce qui correspond à ce schéma :