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.
- Go
- Go
- Pascal
- Pascal
- PHP
- PHP
- C
- Caml
- C++
- C#
- D
- Dart
- Erlang
- Fortran
- Haskell
- JS
- Java
- Lua
- Obj-C
- Perl
- Python
- Ruby
- Rust
- Scala
- Scheme
type Tree[L any] struct {
Label L
Children []*Tree[L]
}The type parameter L is for arbitrary node label data.
A nil *Tree denotes the empty tree.
A nil *Tree denotes the empty tree.
type Tree struct {
Key keyType
Deco valueType
Children []*Tree
}
keyType should be easily comparable.
valueType is a type of value associated with current node.
Children is a slice of pointers.
Note that in Go you can call methods of pointer type *Tree even on a nil receiver (an empty tree).
valueType is a type of value associated with current node.
Children is a slice of pointers.
Note that in Go you can call methods of pointer type *Tree even on a nil receiver (an empty tree).
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>;
This Example uses generics
final class Node {
public function __construct(public array $children, public mixed $data) {}
}In >php 8.0 the code can be simplified a lot
class Tree
{
public $children = [];
public $data;
public function __construct($data, $children)
{
$this->data = $data;
$this->children = $children;
}
}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;
}struct Node(T){
Node[] children;
T data;
}
alias TreeOfIntegers = Node!(int);Inside template Node(T), Node is an alias for the instantiated type.
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_tdata Tree a = Node {
value :: a,
children :: [Tree a]
}class Node {
constructor (value, children = []) {
this.value = value
this.children = children
}
}class Tree<K,V> {
K key;
V deco;
List<Tree<K,V>> children = new ArrayList<>();
}Then you will want to add constructors, getters, setters.
local function Tree(v, c)
return {
val = v,
children = c
}
end@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
Compare also #9
my $tree = {
'Root' => {
'Child1' => {
'GrandChild1' => {},
'GrandChild2' => {}
},
'Child2' => {}
}
};The natural way to create a tree in perl is using hash references.
To add a new item:
$tree->{Root}->{Child2}->{GrandChild3} = {};
To add a new item:
$tree->{Root}->{Child2}->{GrandChild3} = {};
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))
(define (tree-first-child t) (cadr t))
(define (tree-rest-children t) (cddr t))children is list of trees