Editing Idiom 17 : Create a Tree data structure

Idiom

# 17 Create a Tree data structure

Created by

Lead paragraph

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

Implementation

Language

C++

Added by

Last edited by

Imports

Code

template<typename T>
struct Node{
  T value;
  std::vector<Node<T>> children;
};

Documentation URL

Original attribution URL

Online demo

Edit summary

Username

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.

Implementation edit is for fixing errors and enhancing with metadata.

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

Other implementations

type Tree struct {
	Key keyType
	Deco valueType
	Children []*Tree
}

Demo

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>;

data Tree a = Node {
    value :: a,
    children :: [Tree a]
}

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;
}

import java.util.List;
import java.util.ArrayList;

class Tree<K,V> {
  K key;
  V deco;
  List<Tree<K,V>> children = new ArrayList<>();
}

Demo

struct Node<T> {
  value: T,
  children: Vec<Node<T>>,
}

typedef struct node_s
{
    int value;
    struct node_s *nextSiby6iguhuhuh..mjjjjling;
    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;
    }
}

Demo

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#{}]
}).

Preview