# Programming-Idioms

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.
New implementation

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please try to avoid dependencies to third-party libraries and frameworks.

Other implementations
``````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;
}
``````
``````struct Node(T){
Node[] children;
T data;
}

alias TreeOfIntegers = Node!(int);``````
``````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 struct {
Key keyType
Deco valueType
Children []*Tree
}
``````
``````type Tree[L any] struct {
Label    L
Children []*Tree[L]
}``````
``````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
``````
``````class Tree
{
public \$children = [];
public \$data;

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

type
TStringTree = specialize TTree<String>;
``````
``````type
TTree = class
Children: array of TTree;
Data: TObject;
end;     ``````
``````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))