traversal

I thought this problem had a trivial solution, couple of for loops and some fancy counters, but apparently it is rather more complicated. So my question is, how would you write (in C) a function traversal of a square matrix in diagonal strips. Example: 1 2 3 4 5 6 7 8 9 Would have to be traversed in the following order: [1],[2,4],[3,5,7],[6,8],[9] Each strip above is enclosed by square brackets. One of the requirements is being able to distinguish between strips. Meaning that you know when you're starting a new strip. This because there is another function that I must call for each item in a

Given a query like the following: START n = node(123) MATCH p = n-[r:LIKES*..3]->x RETURN p; The result paths that I get with the query above contain cycles. How can I return only simple paths? Given this example : How can I avoid paths with repeated nodes like: [Neo, Morpheus, Trinity, Morpheus, Neo] Specifying the uniqueness of paths is a planned feature of cypher. So right now we have to ascertain that no node is a duplicate in the path. There is an ALL predicate that must hold true for all elements of a collection (which a path is). And with filter you can extract the elements of an

Consider the situation where you have two lists of nodes of which all you know is that one is a representation of a preorder traversal of some tree and the other a representation of a postorder traversal of the same tree. I believe it is possible to reconstruct the tree exactly from these two lists, and I think I have an algorithm to do it, but have not proven it. As this will be a part of a masters project I need to be absolutely certain that it is possible and correct (Mathematically proven). However it will not be the focus of the project, so I was wondering if there is a source out there

I have written a recursive DFS algorithm to traverse a graph: void Graph<E, N>::DFS(Node n) { std::cout << ReadNode(n) << " "; MarkVisited(n); NodeList adjnodes = Adjacent(n); NodeList::position pos = adjnodes.FirstPosition(); while(!adjnodes.End(pos)) { Node adj = adjnodes.ReadList(pos); if(!IsMarked(adj)) DFS(adj); pos = adjnodes.NextPosition(pos); } } Then I have written an iterative DFS algorithm using a stack: template <typename E, typename N> void Graph<E, N>::IterativeDFS(Node n) { Stack<Node> stack; stack.Push(n); while(!stack.IsEmpty()) { Node u = stack.Read(); stack.Pop(); if(

I know that we can use os.walk() to list all sub-directories or all files in a directory. However, I would like to list the full directory tree content: - Subdirectory 1: - file11 - file12 - Sub-sub-directory 11: - file111 - file112 - Subdirectory 2: - file21 - sub-sub-directory 21 - sub-sub-directory 22 - sub-sub-sub-directory 221 - file 2211 How to best achieve this in Python? Here's a function to do that with formatting: import os def list_files(startpath): for root, dirs, files in os.walk(startpath): level = root.replace(startpath, '').count(os.sep) indent = ' ' * 4 * (level) print('{}{}/'

What is the algorithm for doing a post order traversal of a binary tree WITHOUT using recursion? 1337c0d3r Here's a link which provides two other solutions without using any visited flags. https://leetcode.com/problems/binary-tree-postorder-traversal/ This is obviously a stack-based solution due to the lack of parent pointer in the tree. (We wouldn't need a stack if there's parent pointer). We would push the root node to the stack first. While the stack is not empty, we keep pushing the left child of the node from top of stack. If the left child does not exist, we push its right child. If it's