Question

Given a randomly distributed set of keys, with each key mapped to a set of values, how would you transform it into multiple trees?

Example Data Set

• NB₂ => {NC₂ ND₂}
• ND₁ => {NG₁ NH₁}
• NA₁ => {NB₁}
• NB₁ => {NC₁ ND₁ NE₁}
• NA₂ => {NB₂}
• NC₁ => {NF₁}
• NE₁ => {NI₁ NJ₁ NK₁}

Resulting Tree for NA₁

NA1
`-- NB1
    |-- NC1
    |   `-- NF1
    |-- ND1
    |   |-- NG1
    |   `-- NH1
    `-- NE1
        |-- NI1
        |-- NJ1
        `-- NK1

Resulting Tree for NA₂

NA2
`-- NB2
    |-- NC2
    `-- ND2

Answer 1

I’m not aware of any library methods that will do this transformation. Here’s how I’d do it. It’s pretty straightforward, IMO.

public class Tree {
    public Tree(String key) {
        // ...
    }
    public void addChild(Tree child) {
        // ...
    }
}

public Set<Tree> transform(Map<String, List<String>> input) {
    // Potential tree roots.  We start with all LHS keys as potential roots,
    // and eliminate them when we see their keys on the RHS.
    Set<String> roots = new HashSet<String>(input.keySet());

    // This map associates keys with the tree nodes that we create for them
    Map<String, Tree> map = new HashMap<String, Tree>();

    for (Map.Entry<String, List<String>> entry : input.entrySet()) {
        String key = entry.getKey();
        List<String> childKeys = entry.getValue();
        Tree tree = map.get(key);
        if (tree == null) {
            tree = new Tree(key);
            map.put(key, tree);
        }
        for (String childKey : childKeys) {
            roots.remove(childKey);
            Tree child = map.get(childKey);
            if (child == null) {
                child = new Tree(childKey);
                map.put(childKey, child);
            }
            tree.addChild(child);
        }
    }
    Set<Tree> res = new HashSet<Tree>(roots.size());
    for (String key : roots) {
        res.add(map.get(key));
    }
    return res;
}

EDIT: Note this algorithm will “work” if the input represents a set of DAGs (Directed Acyclic Graphs). However, I’ve just realized that the resulting a set of trees will share TreeNode instances for any common subtrees in the input data.

Beware that I haven’t debugged this code 🙂