Visualize a tree: Difference between revisions

=={{header|11l}}==

{{trans|D}}

String value

Node? left

 

V tree = Node(1, Node(2, Node(4, Node(7)), Node(5)), Node(3, Node(6, Node(8), Node(9))))

 

=={{header|Ada}}==

Prints a tree of the current directory.

 

procedure Directory_Tree is

begin

Print_Tree(Ada.Directories.Current_Directory);

 

{{out}}

 

=={{header|ALGOL 68}}==

 

# mode representing nodes of the tree #

animals /:= fish +:= reptiles +:= mammals;

 

{{out}}

<table border="1" cellspacing="4">

{{Trans|Python}}

{{Trans|JavaScript}}

-- box-drawing characters, with options for compacting

-- and pruning.

set my text item delimiters to dlm

str

{{Out}}

<pre>(NB – view in mono-spaced font)

=={{header|Batch File}}==

Displays a tree of the current directory.

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

This creates a native Windows Tree View control:

ON ERROR SYS "MessageBox", @hwnd%, REPORT$, 0, 0 : QUIT

IF hnode% = 0 ERROR 100, "TVM_INSERTITEM failed"

SYS "InvalidateRect", hTree%, 0, 0

[[File:visualize_tree_bbc.gif]]

 

=={{header|C}}==

Print a simple tree to standard output:

#include <stdlib.h>

 

tree(n, 0);

return 0;

{{out}}

<pre>

 

=={{header|C++}}==

#include <iostream>

#include <random>

 

return 0;

{{out}}

<pre>Node(Node(Node(Node(Node(-,4,-),17,Node(-,22,-)),28,-),30,Node(Node(-,36,-),48,Node(Node(Node(-,77,-),81,-),91,-))),100,Node(Node(Node(Node(-,117,-),125,Node(Node(-,131,-),151,Node(-,158,Node(-,163,-)))),176,Node(Node(-,192,-),193,-)),200,-))</pre>

 

=={{header|C sharp}}==

 

public static class VisualizeTree

}

{{out}}

<pre>

 

=={{header|Clojure}}==

 

(draw-tree [[:A] [:B] [:C [:D [:E] [:F]] [:G]]])

{{out}}

<pre>

 

=={{header|Common Lisp}}==

(labels

((rprint (list)

branches))

(terpri)))))))

{{out}}

A

|

G

or

(defun print-tree (tree value-function children-function)

(labels

(do-print-tree child (format nil "~a " prefix)))))))

(do-print-tree tree "")))

{{out}}

(aa

(aaa

├─ ACB

└─ ACC

 

=={{header|D}}==

{{trans|Haskell}}

 

struct Node(T) { T value; Node* left, right; }

const tree = N(1, N(2, N(4, N(7)), N(5)), N(3, N(6, N(8), N(9))));

writefln("%-(%s\n%)", tree.treeIndent);

{{out}}

<pre>--1

{{libheader| System.SysUtils}}

{{Trans|Go}}

program Visualize_a_tree;

 

 

{$IFNDEF UNIX} readln; {$ENDIF}

{{out}}

<pre>┐root

=={{header|Elena}}==

ELENA 5.0 :

import extensions;

 

console.writeTree(tree).readChar()

{{out}}

<pre>

 

=={{header|F_Sharp|F#}}==

| T of string * tree list

 

 

visualize example prefNone

{{out}}

<pre>root

=={{header|Factor}}==

Factor's prettyprinter does this by default with any nested sequences and/or tuples. There are dynamic variables that can be altered to change the prettyprinter's default behavior. The most interesting are <code>tab-size</code> and <code>margin</code> for customizing the look of a tree. For smaller trees, it's best to change <code>margin</code> from its default of <code>64</code> to something low, perhaps <code>10</code>.

 

CONSTANT: mammals { "mammals" { "deer" "gorilla" "dolphin" } }

CONSTANT: reptiles { "reptiles" { "turtle" "lizard" "snake" } }

 

{{out}}

<pre>

</pre>

An example showcasing tuples by displaying an AVL tree:

{{out}}

<pre>

=={{header|FreeBASIC}}==

{{trans|Yabasic}}

 

Sub showTree(n As Integer, A As String)

Print !"\n\n\n"

showTree(0, "[1[2[3[4]]][5[6][7[8][9]]]]")

 

 

===JSON===

Not the most economical output, but at least json.MarshalIndent is in the Go standard library. Note that the definition of Node has nothing JSON specific about it; it's an ordinary struct.

 

import (

}

fmt.Println(string(b))

{{out}}

<pre>

===TOML===

It works in this case, but TOML wasn't really designed for this and encoders may have trouble with general trees. Empty trees and nils for example might be problematic depending on your data structures and limitations of your TOML encoder. YMMV.

 

import (

log.Fatal(err)

}

{{out}}

<pre>

===Unicode===

A non-library solution, more like a number of other solutions on this page, and with more compact output. The tree representation here uses integer indexes rather than pointers, which is efficient for representation and computation. A serialization format like JSON or TOML wouldn't see it as a hierarchical structure, but the code here knows to interpret the child ints as node indexes.

 

import "fmt"

}

f(0, "")

{{out}}

<pre>

=={{header|Haskell}}==

Tree borrowed from [[Tree traversal]]:

deriving (Show, Eq)

 

ls = treeIndent$left t

 

{{out}}

<pre>

We can ''fmap show'' over our tree of integers to derive a tree of strings, and apply `drawTree` to that.

 

 

tree :: Tree Int

 

main :: IO ()

{{Out}}

<pre>1

 

The following works in both languages.

showTree("", " -", [1, [2,[3],[4,[5],[6]],[7,[11]]], [8,[9,[10]]] ])

write()

showTree(prefix, "`-", A[*A])

}

 

Output:

Or, adapted to the [[Tree_traversal#J:_Alternate_implementation|parent index]] representation of a tree (which allows different nodes to share labels and may also be more convenient for other reasons):

 

EW =: {: BOXC NB. east-west

 

 

extend=: 3 : '(+./\"1 (y=EW) *. *./\."1 y e.'' '',EW)}y,:EW'

 

Example use:

 

┌─ 6

┌─ 1 ─── 3 ─┴─ 7

│ ┌─ 8

─ 0 ─┤ ┌─ 4 ─┴─ 9

 

For comparison purposes, here's the node labels along with (in the following row) the index of their parent node:

 

0 1 2 3 4 5 6 7 8 9

 

Also, note that labels can be arbitrary. Here, we used numeric labels because they were concise and convenient. But, for example, we can replace the label '0' with 'george' and the label '4' with 'fred':

 

┌─ 6

┌─ 1 ─── 3 ────┴─ 7

│ ┌─ 8

─ george ─┤ ┌─ fred ─┴─ 9

 

=={{header|Java}}==

Minimalist BST that can do nothing except print itself to stdout.

public static void main(String[] args) {

BinarySearchTree tree = new BinarySearchTree();

}

}

 

<pre> 100

===HTML===

Javascript wrapped in HTML5 document. ''Should'' work in modern browsers.

<html id="doc">

<head><meta charset="utf-8"/>

<div id="tree"><a href="javascript:dom_tree('doc')">click me</a></div>

</body>

 

===Plain text===

====Vertically centered tree====

{{Trans|Python}} (Functional version)

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>Compacted (parents not all vertically centered):

 

====Decorated outline====

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>Alpha

</pre>

 

# Output: a stream of strings representing the tree

# In this implementation, empty arrays in the tree are simply ignored.

 

. as $tree

'''Examples'''

["a",

["aa",

| ("Tree with array representation:\n\(.)\n",

printTree,

{{out}}

<pre>

=={{header|Julia}}==

Run from Julia REPL.

 

gx = kronecker(5, 12, 0.57, 0.19, 0.19)

gplot(gx)

 

=={{header|Kotlin}}==

{{trans|C}}

 

import java.util.Random

val n = 8

tree(n, null)

 

Sample output (unlike the C entry, should be different each time it's run):

 

=={{header|Lingo}}==

-- (minimal implementation with direct property access)

 

me.printTree(c, indent&" ")

end repeat

Usage:

root = script("TreeItem").new("root")

a = script("TreeItem").new("a")

 

-- print the tree

 

{{Out}}

=={{header|Lua}}==

{{trans|C#}}

if type(ac) == "table" then

return {value=v,children=ac}

})

})

{{out}}

<pre>A

 

=={{header|Maple}}==

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Make a tree graph. In Mathematica, '''\[DirectedEdge]''' will appear as an arrow in the code.

 

3 \[DirectedEdge] 6, 4 \[DirectedEdge] 7};

 

[[File:Tree.jpg]]

Show the syntactical structure of the above code. '''Defer''' is added to impede '''TreeGraph''' from becoming a graphical object.

 

TreeGraph[{1 \[DirectedEdge] 2, 1 \[DirectedEdge] 3, 2 \[DirectedEdge] 4, 2 \[DirectedEdge] 5,

 

[[File:syntax.jpg]]

Here's another way to display a tree. The triangles open/close when clicked on.

 

OpenerView[{3, OpenerView[{TraditionalForm[Cos[x]], Plot[Cos[x], {x, 0, 10}, ImageSize -> 150]},

 

[[File:opener.jpg]]

 

=={{header|Maxima}}==

 

g: random_tree(10)$

true

 

 

=={{header|Nim}}==

{{trans|Haskell}}

 

type

let tree = 1.n(2.n(4.n(7.n),5.n),3.n(6.n(8.n,9.n)))

 

 

{{out}}

=={{header|Perl}}==

 

use warnings;

use strict;

my $tree = 'a(b0(c1,c2(d(ef,gh)),c3(i1,i2,i3(jj),i4(kk,m))),b1(C1,C2(D1(E),D2,D3),C3))';

my $parsed = [parse($tree)];

{{out}}

<pre> a

 

=={{header|Phix}}==

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\VisualiseTree.exw

<span style="color: #000080;font-style:italic;">--pp(tree,{pp_Nest,10})</span>

<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>

{{out}}

<pre>

</pre>

A much simpler but less aesthetically pleasing way is just

<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tree</span><span style="color: #0000FF;">,{</span><span style="color: #004600;">pp_Nest</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

'view' is a built-in function in PicoLisp.

 

 

Output:

===XPCE===

XPCE is the SWI-Prolog native GUI library.

display_tree(Direction) :-

sformat(A, 'Display tree ~w', [Direction]),

send(D, display, T),

send(D, open).

[[File:display_tree.png|900px]]

 

 

If you set the presumed width of the output to 1 then pprint will print each level of a nested tuple (which is Pythons obvious method of creating a tree), on a separate line:

[GCC 4.6.3] on linux2

Type "copyright", "credits" or "license()" for more information.

7,

8)

 

pprint (and print), prints Pythons standard container types in a format that is valid python so Python could parse its output:

>>> pprint(tree, width=1)

('a',

>>> tree == copypasteoutput

True

 

pprints width parameter allows it to fold some structure to better fit the page:

('a',

('b0',

'b1',

('C1', 'C2', ('D1', 'E', 'D2', 'D3'), 'C3')))

 

pprint works with with a mix of nested container types. Here we create a tree from both lists and tuples:

... 'i3', 'jj', 'i4', ['kk', 'm'])), 'b1', ('C1', 'C2', ('D1', 'E',

... 'D2', 'D3'), 'C3'))]

'b1',

('C1', 'C2', ('D1', 'E', 'D2', 'D3'), 'C3'))]

 

 

 

{{Works with|Python|3}}

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Fully compacted (parents not all centered):

====Simple decorated-outline tree====

{{Works with|Python|3}}

 

from itertools import (chain, repeat, starmap)

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>1

 

=={{header|Racket}}==

#lang racket/base

 

 

(visualize '(1 (2 (3 (4) (5) (6 (7))) (8 (9)) (10)) (11 (12) (13))))

 

Output:

(formerly Perl 6)

 

:$indent = '',

:@mid = ('├─', '│ '),

my $tree = root=>[a=>[a1=>[a11=>[]]],b=>[b1=>[b11=>[]],b2=>[],b3=>[]]];

 

 

{{out}}

 

=={{header|REXX}}==

* 10.05.2014 Walter Pachl using the tree and the output format of C

**********************************************************************/

node.a.0level=node.father.0level+1

Return

{{out}}

<pre>R

=={{header|Ruby}}==

Modifying [[Tree_traversal#Ruby]] by adding somewhere after the line

root = BinaryTreeNode.from_array [1, [2, [4, 7], [5]], [3, [6, [8], [9]]]]

the lines

require 'pp'

pp root

will produce:

{{out}}

@value=1>

</pre>

def ptree(tree,indent=" ")

case tree

end

ptree [1,2,3,[4,5,6,[7,8,9]],3,[22,33]]

will produce:

{{out}}

=={{header|Rust}}==

Console visualization of binary trees translated from parts of [http://rosettacode.org/wiki/AVL_tree/C the C AVL tree solution].

extern crate rustc_serialize;

extern crate term_painter;

println!("{}", tree);

}

{{out}}

[[File:Visualize_a_tree-rust-1.png]]

=={{header|Sidef}}==

{{trans|Raku}}

indent = '',

mids = ['├─', '│ '],

 

var tree = 'root':['a':['a1':['a11':[]]],'b':['b1':['b11':[]],'b2':[],'b3':[]]]

{{out}}

<pre>

=={{header|Tcl}}==

{{tcllib|struct::tree}}

 

proc visualize_tree {tree {nameattr name}} {

}

}

Demonstrating:

struct::tree t deserialize {root {} {} a 0 {} d 3 {} e 3 {} f 9 {} b 0 {} c 0 {}}

{{out}}

<pre>

{{trans|C}}

{{libheader|Wren-dynamic}}

import "random" for Random

 

 

var n = 8

 

{{out}}

 

=={{header|Yabasic}}==

 

dim colore$(1)

end switch

end sub

 

=={{header|zkl}}==

It does this with data that looks like:

L("Network.TCPServerSocket","File","ZKLShell.Granny","Int","startup","Utils.Inspector","Thread.Straw","Ref","Utils.Argh" ...)

const INDENT=" ";

space:=""; lastPath:=L();

"" // so startup has something to display

}

 

=={{header|PHP}}==

<?php

 

 

?>

 

{{out}}