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

</tr>

</table>

 

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

 

=={{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>

`--1

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

 

=={{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

| `-- (null)

`-- (null)</pre>

=={{header|Elena}}==

import extensions;

 

console.writeTree(tree).readChar()

{{out}}

<pre>

| +---d

|

</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|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

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

 

=={{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===

====Decorated outline====

'use strict';

 

};

 

// GENERIC FUNCTIONS ----------------------------------

 

// MAIN ---

return main();

{{Out}}

<pre>Alpha

│

└─ Lambda</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}}

</pre>

 

 

=== Tree graph ===

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

data: T

left, right: Node[T]

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

 

 

=={{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

│ └─D3

└─C3</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

</pre>

A much simpler but less aesthetically pleasing way is just

{{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).

=={{header|Python}}==

===Library module===

 

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'))]

 

 

===Functional composition===

Using the same tree structure (including tree node constructor and accessors) as in the [[Tree_traversal|Tree Traversal]] task, and centering parent nodes vertically:

 

{{Works with|Python|3}}

 

from functools import reduce

def measured(x):

'''Value of a tree node

'''

s = ' ' + str(x) + ' '

 

# lmrFromStrings :: [String] -> ([String], String, [String])

def lmrFromStrings(xs):

i = len(xs) // 2

 

# stringsFromLMR :: ([String], String, [String]) -> [String]

def leftPad(n):

return lambda s: (' ' * n) + s

 

# treeFix :: (Char, Char, Char) -> ([String], String, [String])

# -> [String]

def treeFix(l, m, r):

return compose(stringsFromLMR)(

fghOverLMR(cfix(l), cfix(m), cfix(r))

)

)

 

return lambda blnPruned: (

])

 

 

 

# MAIN ---

if __name__ == '__main__':

{{Out}}

┌ 4 ─ 7

┌ 2 ┴ 5

└─ Lambda </pre>

 

{{Works with|Python|3}}

 

from operator import (add)

 

add,

zip(

xs

)

value of some kind to a list of zero or

more child trees.'''

 

 

# 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:

\-13

</pre>

 

=={{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}}==

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>

├─b

└─c

</pre>

 

=={{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

}