Traversal | Enumeration & iteration of collections in Swift

After submitting this as an issue in the source repository, the behaviour is confirmed to be a bug (more like a current limitation because no control-flow analysis is done when using logical assignment operators as opposed to short-circuiting assignment with logical operators).

You have a reasonable-looking sequence of if tests (though using cond instead would be more idiomatic Scheme). But the values you return do not generally look correct.

The first problem I see is in your first if clause. If both trees are empty, you return '(). But according to the spec, you should be calling the succ function with that result. This may look unimportant if you use id as your continuation, but note that each recursive step builds up a more detailed succ continuation, so in general succ may be a quite impactful function.

The second if is also a problem. Again you return '(), when you are supposed to return the first conflicting subtrees. It's not clear to me what that means, but it would be reasonable to pass a pair of tree1 and tree2 to fail.

The third and fourth clause look fine. You call succ with a pair of the two leaves, as expected.

The recursive call is clearly wrong: you have mis-parenthesized calls to cons, and your lambda variable is named X but you refer to it as x. The series of cons calls doesn't really look right either, but you can experiment with that once your more pressing syntactic issues are resolved and your base cases work properly.

Lastly, you are doing a lot of low-level work with cons, car, '(), and so on. You should be using the abstract functions provided to you, such as add-subtree and (make-tree), instead of using the low-level primitives they are built on.

You can extend the node object with a custom property like DOM and append children to the DOM of the parent node:

In case of binary trees, the #edges = #vertices - 1. The traversal takes O(|E|) or O(|V|) time.

In case of non-binary trees, #edges = #vertices - 1 still holds true. So, traversal still takes O(|E|) or O(|V|) time.

Getting every possible path takes same amount of time as traversal = O(|E|) or O(|V|).

If you want to print all the stored paths, it could take O(length of the longest path * number of paths).

Total time complexity =Traversal + Print = O(|E|) + O(length of the longest path * number of paths).

I got the answer, in the second for loop I was incrementing itr rather than ptr that was causing the error, it was just a silly mistake I can say.

You could filter out the edges from/to soft-deleted nodes

While trying to debug the code, the problem seemed to be in the whole concept of the attribute next in the Node class.

When I printed out all of the Nodes' next lists, I found multiple occurences of the same Node, for example [2,2,2,3,8,...] so when I converted the list to set it didn't get stuck anymore.

Hope this helps someone in the future.

Edge IDs in JanusGraph are stored using a special class called RelationIdentifier that contains a lot more information than just the ID itself. The ID of that class is a "UUID like" identifier. You can get other information from the class. Below is an example using a simple 'inmemory' JanusGraph from the Gremlin Console.