Struct Node

pub struct Node<T> {
    pub value: T,
    pub children: Vec<Node<T>>,
}

A generic tree node implementation.

This struct provides a simple implementation of a tree node with a value and a vector of children. It implements both TreeNode and TreeNodeMut traits, allowing it to be used with both immutable and mutable iterators.

Type Parameters

• T - The type of value stored in each node.

Examples

use tree_iter::tree::Node;
use tree_iter::prelude::*;

// Create a simple tree
let tree = Node {
    value: 1,
    children: vec![
        Node {
            value: 2,
            children: vec![],
        },
        Node {
            value: 3,
            children: vec![],
        },
    ],
};

// Traverse in depth-first order
let values: Vec<i32> = tree.iter::<DepthFirst>()
                          .map(|node| node.value)
                          .collect();
assert_eq!(values, vec![1, 2, 3]);

Fields

value: T

The value stored in this node.

children: Vec<Node<T>>

The children of this node.

Trait Implementations

impl<T> TreeNode for Node<T>

Implementation of TreeNode for Node<T>.

This allows immutable iteration over the tree.

fn children(&self) -> impl DoubleEndedIterator<Item = &Self> + '_

Returns an iterator over the children of this node.

fn iter<T: TraversalOrder>(&self) -> TreeIter<'_, Self, T>

where Self: Sized,

Creates an iterator that traverses the tree starting from this node.

impl<T> TreeNodeMut for Node<T>

Implementation of TreeNodeMut for Node<T>.

This allows mutable iteration over the tree.

fn children_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut Self> + '_

Returns a mutable iterator over the children of this node.

fn iter_mut<T: TraversalOrder>(&mut self) -> TreeMutIter<'_, Self, T>

where Self: Sized,

Creates a mutable iterator that traverses the tree starting from this node.