private List<ObjBayes> assembleNetwork(List<ConfigObj> estrut, Node node1, Node node2) {

        List<ConfigObj> st = estrut;
        List<ObjBayes> lt = new ArrayList<ObjBayes>();
        List<ObjBayes> lt_hidden_aux = new ArrayList<ObjBayes>();
        List<ObjBayes> lt_mc_aux = new ArrayList<ObjBayes>();
        List<ObjBayes> lt_comparable_aux = new ArrayList<ObjBayes>();
        List<Node> validElem1;
        List<Node> validElem2;

      
        //List<List<Node>> nl = obtemNivel(node1);
        //List<List<Node>> nl2 = obtemNivel(node2);        
        //nl = preencheNivel(nl, estrut);
        //nl2 = preencheNivel(nl2, estrut);

        //Alternativa a soluçao de cima. Parece nao ser mais rapido, apesar de
        //a implementaçao ser mais simples.
        Map<String,List<Node>> nl_on = obtemNivel2(node1);
        Map<String,List<Node>> nl2_on = obtemNivel2(node2);
        List<List<Node>> nl = preencheNivel2(nl_on, estrut);
        List<List<Node>> nl2 = preencheNivel2(nl2_on, estrut);
        
        
        ConfigObj co;
        List<Node> typeLst1;
        List<Node> typeLst2;

        int stSize = estrut.size();
        for (int i = 0; i < stSize; i++) {

            co = st.get(i);
            typeLst1 = nl.get(i);
            typeLst2 = nl2.get(i);

            boolean isLeaf = co.isLeaf();

            if (isLeaf) {
                validElem1 = getValidNodes(typeLst1, co);
                validElem2 = getValidNodes(typeLst2, co);
            } else {
                validElem1 = typeLst1;
                validElem2 = typeLst2;
            }

            // criar nova rede daqui para baixo.

            /*
             * System.out.println("NodeName: " + co.getNodeName());
             * System.out.println("size1: " + validElem1);
             * System.out.println("size2: " + validElem2);
             */

            ValueNode vn = null;

            int validElemSize1 = validElem1.size();
            int validElemSize2 = validElem2.size();

            if (validElemSize1 == 0 || validElemSize2 == 0) {// System.out.println("Hidden");
                vn = buildHiddenValueLeafNode(co, getAttributes(null, null, co));
            } else if (validElemSize1 == 1 && validElemSize2 == 1) {// System.out.println("SingleNode");
                vn = buildSingleValueNode(validElem1.get(0), validElem2.get(0), co);
            } else if (validElemSize1 > 1 || validElemSize2 > 1) {// System.out.println("Multiple");
                vn = buildMultipleChildrenLeaf2(validElem1, validElem2, co);
            }

            if (vn.isHidden())
                lt_hidden_aux.add(vn);
            else
                /* if(vn.isGenericNode() || vn.isMultipleChildren()) */
                lt_comparable_aux.add(vn);

            /*
             * else lt_mc_aux.add(vn);
             */

            // lt.add(vn);

        }

        //Junta os nós comparaveis com os que não apresentam conteudo e, como tal, vão assumir o valor da probabilidade de ausencia
        //Este nós sem conteudo são colocados na rede à frente dos nós com conteudo por o seu valor já ser conhecido e não apresentar necessidade de calculo de similaridade
        //Notar que a ordem definida pela estratégia de ordenação pode não ser respeitada se existirem nós sem conteudo nos objectos
        //Neste caso a ordem é respeitada apenas individualmente para cada lista
        lt = mergeNodes(lt_comparable_aux, lt_hidden_aux);
        // lt = mergeNodes(lt_mc_aux, lt);

        // System.out.println("rede "+lt);
        return lt;
    }