Logo

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.
Implementation
Haskell

Implementation edit is for fixing errors and enhancing with metadata. Please do not replace the code below with a different implementation.

Instead of changing the code of the snippet, consider creating another Haskell implementation.

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating material.

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

Other implementations
type Tree struct {
	Key keyType
	Deco valueType
	Children []*Tree
}
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);
}
  
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>;
Node = Struct.new(:children)
parent = Node.new([])
parent.children << Node.new([])
class Node:
    def __init__(self, value, *children):
        self.value = value
        self.children = list(children)
using System.Collections.Generic
class Node<T>
{
 T value;
 List<Node<T>> childNodes;
}
#include <vector>
template<typename T>
struct Node{
  T value;
  std::vector<Node<T>> children;
};
import java.util.List;
import java.util.ArrayList;
class Tree<K,V> {
  K key;
  V deco;
  List<Tree<K,V>> children = new ArrayList<>();
}
struct Node<T> {
  value: T,
  children: Vec<Node<T>>,
}
typedef struct node_s
{
    int value;
    struct node_s *nextSibling;
    struct node_s *firstChild;
} node_t;
(define (make-tree value children)
  (cons value children))

(define (tree-value t) (car t))
(define (tree-first-child t) (cadr t))
(define (tree-rest-children t) (cddr t))
local function Tree(v, c)
	return {
		val = v,
		children = c
	}
end
class Tree
{
    public $children = [];
    public $data;
    
    public function __construct($data, $children)
    {
        $this->data = $data;
        $this->children = $children;
    }
}
class Node {
  constructor (value, children = []) {
    this.value = value
    this.children = children
  }
}
case class Node[T](value: T, children: List[Node[T]] = Nil)
type 'a Tree = {
	value: 'a;
	children: 'a tree list;
}
my $tree = {
           'Root' => {
                 'Child1' => {
                       'GrandChild1' => {},
                       'GrandChild2' => {}
                 },
                 'Child2' => {}
           }
};
type node_t
  integer:: value
  type(node_t), pointer :: next_sibling;
  type(node_t), pointer :: first_child;
end type node_t
-record( node,{
	value         :: any(),
	children = [] :: [node#{}]
}).
@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 addObject:otherNode];
[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) {}
}
type Tree[L any] struct {
	Label    L
	Children []*Tree[L]
}