algorithm for building a boolean expression from a tree traverse

Question

I´ve and html like this:

<div id="tree">
    <div id="AND" class="node">
        <div id="OR" class="node">
            <div id="a" class="node"></div>
            <div id="b" class="node"></div>
        </div>
        <div id="OR" class="node">
             <div id="c" class="node"></div>
             <div id="d" class="node"></div>
        </div>
    </div>
</div>

I use jquery to get the nodes like this:

$(".node")

And i use a for to form an array like this:

var expresion = ["AND","OR","a", "b", "OR", "c", "d"];

I want to built something like:

a OR b AND c OR d

Does anyone knows an algorith for building boolean expressions. Thanks in advance.

Answer 1

Try prefix traversing over the array: You will be able to construct the expression you desire. This is simple procedure for a programmer, and it will left as an exercise. I will give a hand: read Tree Traversal . It's basically the order the array will be accessed will produce the output you desire.

Answer 2

function travarse(node){
    var result = [];
    var op = node.children("#AND,#OR");
    var len = op.length;
    var term;
    if(len){
      term = op.children(".node");
      result=result.concat(travarse($(term.get(0))));
      result.push(op.get(0).id);
      result=result.concat(travarse($(term.get(1))));
    } else {
      term = node.children(".node");
      result.push(term.get(0).id);
      result.push(node.get(0).id);
      result.push(term.get(1).id);
    }
    return result;
}

//var expresion = $.map($.makeArray($(".node")), function(el){ return el.id; });//["AND", "OR", "a", "b", "OR", "c", "d"]
var expression = travarse($('#tree'));//["a", "OR", "b", "AND", "c", "OR", "d"]

Answer 3

Ideally, you should just do your own in-order traversal of the nodes. See: http://en.wikipedia.org/wiki/In-order_traversal#Inorder_Traversal

---

However, this function should give you the exact functionality you're looking for:

function convertPreOrderArrayToInOrderString(elements)
{
    var cursor = 0;
    // While all the elements aren't merged together
    while (elements.length > 1)
    {
        // Skip to the nextleaf
        while (elements[cursor] === "AND" || elements[cursor] === "OR") cursor++;

        // If we made all the matches we can at this depth, go to the next one
        if (typeof elements[cursor+1] === "undefined") 
        {
            cursor = 0;
            continue;
        }

        // The relevant pieces to combining
        var previous = elements[cursor-1];
        var current = elements[cursor];
        var next = elements[cursor+1];

        // Create a string from the pieces
        var tmpStr = current + " " + previous;

        // How many we've combined
        var combined = 2;

        // If the third piece is complete, we can join it too
        if (next !== "AND" && next != "OR")
        {
            // Tack the third piece on
            tmpStr += " " + next;
            combined++;
        }

        // Remove the individual elements and replace with the combined ones
        var newElements = elements.slice(0, cursor-1);
        newElements.push(tmpStr);
        newElements = newElements.concat(elements.slice(cursor - 1 + combined));

        // From now on, opreate on the new array with combined elements
        elements = newElements;
    }

    // There should be one element left
    return elements[0];
}


var expression = ["AND","OR","AND","a","f","OR","e","b","OR","c","d"];
console.log(convertPreOrderArrayToInOrderString(expression));
// Gives: "a AND f OR e OR b AND c OR d"

Corresponding Fiddle: http://jsfiddle.net/DvZj4/4/

In a more general case, you might prefer to do something like this, though:

function convertPreOrderToInOrder(elements)
{
    // Very simple sanity checks
    if (elements.length === 1 && (elements[0] === "AND" || elements[0] === "OR"))
    {
        console.error("Cannot construct compound expression with boolean connectors without values");
        return;
    }
    else if (elements.length === 1)
    {
        // Only 1 items, just return it
        return elements[0];
    }
    else if (elements.length > 1 && elements[0] !== "AND" && elements[0] !== "OR")
    {
        console.error("Cannot construct compound expression  without boolean connectors");
        return;
    }

    // Convert back to a tree from the preorder, then flatten again in order
    return flattenTreeInOrder(getTreeFromPreOrderArray(elements));
}

// Reconstructs a tree from a pre-ordered array of elements
// Assumes your array of elements can construct a properly
// balanced tree. If it can't, this will get screwy
function getTreeFromPreOrderArray(elements)
{
    var i, el, root = {}, current = root;
    // Iterate over every element
    for (i in elements)
    {
        el = elements[i];
        // Pretty much just a root check
        if ( (el === "AND" || el === "OR") && !current.connector)
        {
            // Make this a root
            current.connector = el;
        }
        // Not a root, can we go left?
        else if (!current.left)
        {
            // Branch left
            if (el === "AND" || el === "OR")
            {
                current.left = {connector: el};
                current.left.parent = current;
                current = current.left;
            }
            // Left left
            else
            {
                current.left = el;
                current.left.parent = current;
            }
        }
        // Not a root, can't go left. Try to the right.
        else
        {
            // Branch right
            if (el === "AND" || el === "OR")
            {
                current.right = {connector: el};
                current.right.parent = current;
                current = current.right;
            }
            // Leaf Right
            else
            {
                current.right = el;
                current.right.parent = current;
                // Tricky bit: If we put a leaf on the right, we need
                // to go back up to the nearest parent who doesn't have
                // right child;
                while (current.parent && current.right)
                {
                    current = current.parent;
                }
            }
        }
    }
    return root;
}

// Flatten a tree into an array using in-order traversal
// No recursion, uses stack-based traversal
// Returns an array of strings
function flattenTreeInOrder(root)
{
    var stack = [];
    var flat = [];
    var current = root;
    // We need to keep going as long as there's either something in the
    // stack, or we're looking at a node.
    while (stack.length > 0 || current)
    {
        // If the looked at node is defined
        // This will help us tell if we've gone past a leaf
        if (current)
        {
            // Don't care during in order traversal. Just push this on
            // and move to the left
            stack.push(current);
            current = current.left;
        } 
        else
        {
            // Starting to go back up, but the current is undefined
            // So, pop first, then start capturing in order elements
            current = stack.pop();
            flat.push(current.connector || current);
            current = current.right;
        }
    }

    return flat;
}


var expression = ["AND","OR","AND","a","f","OR","e","b","OR","c","d"];
console.log(convertPreOrderToInOrder(expression).join(" "));
// Gives: "a AND f OR e OR b AND c OR d"

​ Corresponding Fiddle: http://jsfiddle.net/keR5j/

---

Can't duplicate html element id s

Additionally, you can't use the ids the way you have in your structure. Having multiple instances of the same id , ie two nodes with id="OR" is invalid HTML per the spec: http://www.w3.org/TR/html401/struct/global.html#h-7.5.2

id = name [CS]

This attribute assigns a name to an element. This name must be unique in a document.

---