Budowanie drzewa z danych wejściowch

Mam do wygenerowania drzewo z 01[A]01[G]01[C]1[T] gdzie 0 oznacza węzeł wewnętrzny, a 1 liść. Wygląd drzewa w załączniku.

public class Sign {

    private Character character;

    private Double probability;

    private Double unitOfInformation;

    private Integer occurrences;

class Node {
    private Sign sign;
    private Node left;
    private Node right;

}

Próbowałem to zrobić w ten sposób ale już nie mam pomysłu jak mogę to zrobić

   public Node getHuffmanTree(String treeCode){
        Node node=new Node();
        traverseeHuffmanTree(treeCode,node,node);

        traversePreOrder2(node);
        return node;


    }

    public void traverseeHuffmanTree(String treeCode,Node node,Node root) {
       if(!treeCode.isEmpty()) {
            if(treeCode.charAt(0)=='0') {
                node.setLeft(new Node());
                traverseeHuffmanTree(treeCode.substring(1), node.getLeft(),root);
            }else if(treeCode.charAt(0)=='1') {
                node.setRight(new Node());
                traverseeHuffmanTree(treeCode.substring(1), node.getRight(),root);
            }else if(treeCode.charAt(0)=='[' || treeCode.charAt(0)==']'){
                traverseeHuffmanTree(treeCode.substring(1), node,root);
            }else if(treeCode.charAt(0)!='[' && treeCode.charAt(0)!=']') {
                Sign sign=new Sign();
                sign.setCharacter(treeCode.charAt(0));
                treeCode=treeCode.substring(1);
                node.setSign(sign);
                traverseeHuffmanTree(treeCode,root,root);
            }
        }
    }

package trees;
public class BinarySearchTree<Key extends Comparable<Key>, Value> {
    private Node root;
    private class Node {
        private Key key;
        private Value val;
        private Node left, right;
        private int N;
        public Node(Key key, Value val, int N) {
            this.key=key;
            this.val=val;
            this.N=N;
        }
    }
    public void print() {
        print(root, 0);
    }
    private void print(Node r, int depth) {
        System.out.println(String.join("", Collections.nCopies(depth, " ")) + "|____"+ r.key + " " +r.val);
        if(r.left!=null) print(r.left, depth+2);
        if(r.right!=null) print(r.right, depth+2);
    }
    public int size() { return  size(root); }
    private int size(Node x) {
        if(x==null) return 0;
        else return x.N;
    }
    public Value get(Key key) { return  get(root, key); }
    private Value get(Node x, Key key) {
        if(x==null) return null;
        int cmp=key.compareTo(x.key);
        if(cmp<0) return get(x.left, key);
        else if(cmp>0) return get(x.right, key);
        else return x.val;
    }
    public void put(Key key, Value val) { root = put(root, key, val); }
    private Node put(Node x, Key key, Value val) {
        if(x==null) return new Node(key,val,1);
        int cmp = key.compareTo(x.key);
        if(cmp<0) x.left=put(x.left, key, val);
        else if(cmp>0) x.right=put(x.right,key,val);
        else x.val=val;
        x.N= size(x.left) + size(x.right)+1;
        return x;
    }
    public Key min() {
        return min(root).key;
    }
    public void deleteMin() {
        Node min = min(root);
        min=min.right;
    }
    private Node deleteMin(Node x) {
        if(x.left==null) return x.right;
        x.left=deleteMin(x.left);
        x.N=size(x.left)+size(x.right)+1;
        return x;
    }
    public void delete(Key key) { root=delete(root, key);}
    private Node delete(Node x, Key key) {
        if(x==null) return null;
        int cmp = key.compareTo(x.key);
        if(cmp<0) x.left=delete(x.left, key);
        else if(cmp>0) x.right=delete(x.right, key);
        else {
            if(x.right==null) return x.left;
            if(x.left==null) return x.right;
            Node t = x;
            x=min(t.right);
            x.right=deleteMin(t.right);
            x.left=t.left;
        }
        x.N=size(x.left)+size(x.right)+1;
        return x;
    }
    private Node min(Node x) {
        if(x.left==null) return x;
        return min(x.left);
    }
}


public class BSTMain {
    public static void main(String[] args) {
        BinarySearchTree<Character, Integer> bst = new BinarySearchTree<Character, Integer>();
        String values="EASYQUESTION";
        for(int i=0;i<values.length();i++) {
            bst.put(values.charAt(i), i);
        }
        bst.print();
    }
}

Próbowałem też zrobić coś takiego ale też nie działa

/**
    * Implementation of decoded Huffman tree
    * @return Decoded from file Huffman tree
    */
   public Node getHuffmanTree(String treeCode){
     treeCode=  treeCode.replaceAll("[\\[\\]]","");
       Node root=new Node();
       int i=0;
       while (!treeCode.isEmpty()){
           if(treeCode.charAt(i)=='1'){
               generateHuffmanSubTree(treeCode.substring(0,i+2),root);
               treeCode=treeCode.substring(i+2);
               i=0;
               break;

           }else ++i;
       }


       while (!treeCode.isEmpty()){
           if(treeCode.charAt(i)=='1'){
               Node subTree=new Node();
               generateHuffmanSubTree(treeCode.substring(0,i+2),subTree);
               treeCode=treeCode.substring(i+2);
               i=0;
               //tree merge
               huffmanTreeMerge(root,subTree);

               System.out.println("\n");
               traversePreOrder2(root);
           }else ++i;
       }

       return root;


   }
   private void huffmanTreeMerge(Node root,Node node){
       if(root==null) {
           return;
       }




       if(root.getLeft()!=null && root.getRight()==null){
           if(root.getLeft().getLeft()!=null && root.getLeft().getRight()==null) {
               return; //not low enough
           }else if(root.getLeft().getLeft()!=null && root.getLeft().getRight()!=null){
               root.setRight(node);
               return;
           }else if(root.getLeft().getLeft()==null && root.getLeft().getRight()==null){
               root.setRight(node);
               return;
           }
          // else if(root.getLeft().getLeft()==null && root.getLeft().getLeft()!=null) impossible


       }else if(root.getLeft()==null && root.getRight()==null){
           return;
       }
       huffmanTreeMerge(root.getLeft(),node);
       huffmanTreeMerge(root.getRight(),node);


   }

   private void generateHuffmanSubTree(String treeCode,Node node){

       if(!treeCode.isEmpty()) {
           if (node == null) {
               node = new Node();
           }

           if (treeCode.charAt(0) == '1') {

               Sign sign = new Sign();
               sign.setCharacter(treeCode.charAt(1));
               //    System.out.println(treeCode.charAt(1));
               node.setSign(sign);
               return;
           }else if(treeCode.charAt(0) == '0'){
               node.setLeft(new Node());
               generateHuffmanSubTree(treeCode.substring(1),node.getLeft());
           }
       }
   }

   private void traversePreOrder2(Node node) {
       if (node != null) {

           if(node.getLeft()==null && node.getRight()==null)
               System.out.print("    "+"1"+node.getSign().getCharacter()+"    ");
           else
               System.out.print("0");
           traversePreOrder2(node.getLeft());
           traversePreOrder2(node.getRight());
       }
   }