# Idiom #17 Create a Tree data structure

The structure must be recursive. A node may have zero or more children. A node has access to its children nodes, but not to its parent.

``````struct Node(T){
Node[] children;
T data;
}

alias TreeOfIntegers = Node!(int);``````
``````typedef struct node_s
{
int value;
struct node_s *nextSibling;
struct node_s *firstChild;
} node_t;``````
``````type 'a Tree = {
value: 'a;
children: 'a tree list;
}``````
``#include <vector>``
``````template<typename T>
struct Node{
T value;
std::vector<Node<T>> children;
};``````
``using System.Collections.Generic``
``````class Node<T>
{
T value;
List<Node<T>> childNodes;
}
``````
``````class Node<T> {
final T value;
final List<Node<T>> children;
Node(this.value, this.children);
}
``````
``````-record( node,{
value         :: any(),
children = [] :: [node#{}]
}).``````
``````type node_t
integer:: value
type(node_t), pointer :: next_sibling;
type(node_t), pointer :: first_child;
end type node_t``````
``````type Tree[L any] struct {
Label    L
Children []*Tree[L]
}``````
``````type Tree struct {
Key keyType
Deco valueType
Children []*Tree
}
``````
``````data Tree a = Node {
value :: a,
children :: [Tree a]
}``````
``````class Node {
constructor (value, children = []) {
this.value = value
this.children = children
}
}``````
``````import java.util.List;
import java.util.ArrayList;``````
``````class Tree<K,V> {
K key;
V deco;
List<Tree<K,V>> children = new ArrayList<>();
}``````
``````local function Tree(v, c)
return {
val = v,
children = c
}
end``````
``@import Foundation;``
``````@interface Node:NSObject
@property id value; // id means any object value
@property NSMutableArray *children;
@end

// usage like
Node *n=[Node new];
n.value=@1;
[n.children removeLastObject];

// somewhere needed also
@implementation Node
-(instancetype)init {
if (!(self=[super init])) return nil;
_children=[NSMutableArray array];
return self;
}
@end
``````
``````final class Node {
public function __construct(public array \$children, public mixed \$data) {}
}``````
``````class Tree
{
public \$children = [];
public \$data;

public function __construct(\$data, \$children)
{
\$this->data = \$data;
\$this->children = \$children;
}
}``````
``````type
TTree = class
Children: array of TTree;
Data: TObject;
end;     ``````
``````type
generic
TTree<_T> = class(TObject)
Children: array of TObject;
Data: _T;
end;

type
TStringTree = specialize TTree<String>;
``````
``````my \$tree = {
'Root' => {
'Child1' => {
'GrandChild1' => {},
'GrandChild2' => {}
},
'Child2' => {}
}
};``````
``````class Node:
def __init__(self, value, *children):
self.value = value
self.children = list(children)``````
``````Node = Struct.new(:children)
parent = Node.new([])
parent.children << Node.new([])``````
``````struct Node<T> {
value: T,
children: Vec<Node<T>>,
}``````
``case class Node[T](value: T, children: List[Node[T]] = Nil)``
``````(define (make-tree value children)
(cons value children))

(define (tree-value t) (car t))