Traversal implements generic and lazy tree traversal algorithms.

Includes:

• Breadth-First Traversal (Bft)
• Depth-First Traversal in Pre-Order (DftPre)
• Depth-First Traversal in Post-Order (DftPost)
• Reverse Depth-First Traversal in Pre-Order (DftPreRev)
• Reverse Depth-First Traversal in Post-Order (DftPostRev)

• All Paths (DftPaths)
• Longest Paths (DftLongestPaths)
• All Cycles (Paths) (DftCycles)

Traversal uses generics (or type parameters) to be flexible to use, and easy to implement and fit into existing architecture.

Laziness or lazy evaluation refers to evaluation being delayed until needed.

Traversal delays processing Nodes and fetching child Nodes until Iterator::next is called. When next is called, then traversal only processes the Nodes required for this iteration.

From Rust's docs:

Iterators (and iterator adapters) are lazy. This means that just creating an iterator doesn't do a whole lot. Nothing really happens until you call next.

— Iterator - Laziness

Add this to your Cargo.toml:

[dependencies]
traversal = "0.1"

Release notes are available in the repo at CHANGELOG.md.

     A
    / \
   B   C
  / \ / \
 D  E F  G

Given the above tree, then the following are the orders, that each individual iterator / traversal algorithm produces.

See each individual algorithm for code examples.

DftPaths and DftLongestPaths are utilities for iterating all paths and the longest paths in a tree.

Given the same tree as the previous examples, then DftPaths and DftLongestPaths produce the following paths.

DftPaths:

• A, B
• A, B, D
• A, B, E
• A, C
• A, C, F
• A, C, G

DftLongestPaths:

• A, B, D
• A, B, E
• A, C, F
• A, C, G

See each individual algorithm for code examples.

  A <---+
 / \    |
B   D >-+
|   |   |
C   E >-+

DftCycles:

• A -> D (implies D is connected with A)
• A -> D -> E

See each individual algorithm for code examples.