New implementation

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating resource.

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
}
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
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(object):
    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<Box<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))
(define (tree-first-child t) (cadr t))
(define (tree-rest-children t) (cddr t))