tree-traversal

I was trying to understand how it is so intuitive to implement postorder traversal using 2 stacks. How did someone come up with it, is it just an observation or some particular way of thinking which helps one come up with such methods. If yes then please explain how to think in the right direction. Let me explain how I stumbled on the solution: You start off with this simple observation: prima facie, the pre-order and post-order traversal differ only in their order of operations : preOrder(node): if(node == null){ return } visit(node) preOrder(node.leftChild) preOrder(node.rightChild)

I have a graph with two edge definitions like this: isDepartment: [organisation] -> [organisation] hasAccess: [user] -> [organisation] Organisations are nested in a tree (no cycles). There are multiple top-level organisations without any incoming isDepartment edges. Users are granted access to one or more organisations. These can be top-level organisations or organisations somewhere lower down the tree. If a user has access to an organisation, it has access to all child organisations. I am trying to build a custom visitor or filter that gives me all accessible organisations for a user,

Given the code for outputing the postorder traversal of a tree when I have the preorder and the inorder traversal in an integer array. How do I similarly get the preorder with the inorder and postorder array given? void postorder( int preorder[], int prestart, int inorder[], int inostart, int length) { if(length==0) return; //terminating condition int i; for(i=inostart; i<inostart+length; i++) if(preorder[prestart]==inorder[i])//break when found root in inorder array break; postorder(preorder, prestart+1, inorder, inostart, i-inostart); postorder(preorder, prestart+i-inostart+1, inorder, i+1,

I have the following recursive data structure and a method iterating over it. Whilst doing so it should add a unique number n to each node e.g. its respective number in level order traversal of the tree. var data = { children: [ { children: [ ... ] }, { children: [ ... ] }, { children: [ ... ] }, ... ] } var process = function (node) { node.children.forEach(child, function () { process(child); }); return node; } How can I achieve this without changes to the data structure and minimal changes to the processing function? Result of process(data) should be var data = { n: 1 children: [ { n: 2,

I have been working towards understanding the DOM very thoroughly. At the moment i'm making my way trough traversing the DOM tree and i seem to be finding some inconsistencies. On a nodeList i can use an index to iterate trough the list On a HTMLElement i can't use an index See this fiddle for an example: http://jsfiddle.net/AmhVk/4/ So the question is, why is it that the nodeList has an indexable list like element[0], element 1 and the HTMLElement has not? Could someone explain this to me very thoroughly? Thx... <ul id="jow"> <li><a href="">Item</a></li> <li><a href="">Item</a></li> <li class

Problem: Consider a complete k-ary tree with l levels, with nodes labelled by their rank in a breadth first traversal. Compute the list of labels in the order that they are traversed in the depth first traversal. For example, for a binary tree with 3 levels, the required list is: [0 1 3 7 8 4 9 10 2 5 11 12 6 13 14] One way to do this is to actually construct a tree structure and traverse it twice; The first traversal is breadth first, labelling the nodes 0,1,2,.. as you go. The second traversal is depth first, reporting the labels 0,1,3,7,.. as you go. I'm interested in a method that avoids

Consider a binary tree with the following properties: An internal node (non-leaf node) has a value 1 if it has two children. A leaf node has a value 0 since it has no children. A level order traversal on the tree would generate a string of 1s and 0s (by printing the weird value at each node as they are visited). Now given this string construct the binary tree and perform a post order traversal on the tree. The post order string should be the output of the program. For example: Input String is 111001000 . Create a binary tree from this. Then perform the post order traversal on the tree which