Visualize a tree

From Rosetta Code
Jump to: navigation, search
Task
Visualize a tree
You are encouraged to solve this task according to the task description, using any language you may know.

A tree structure (i.e. a rooted, connected acyclic graph) is often used in programming. It's often helpful to visually examine such a structure. There are many ways to represent trees to a reader, such as indented text (à la unix tree command), nested HTML tables, hierarchical GUI widgets, 2D or 3D images, etc.

Task: Write a program to produce a visual representation of some tree. The content of the tree doesn't matter, nor does the output format, the only requirement being that the output is human friendly. Make do with the vague term "friendly" the best you can.

Contents

[edit] Ada

Prints a tree of the current directory.

with Ada.Text_IO, Ada.Directories; 
 
procedure Directory_Tree is
 
procedure Print_Tree(Current: String; Indention: Natural := 0) is
 
function Spaces(N: Natural) return String is
(if N= 0 then "" else " " & Spaces(N-1));
 
use Ada.Directories;
Search: Search_Type;
Found: Directory_Entry_Type;
 
begin
Start_Search(Search, Current, "");
while More_Entries(Search) loop
Get_Next_Entry(Search, Found);
declare
Name: String := Simple_Name(Found);
Dir: Boolean := Kind(Found) = Directory;
begin
if Name(Name'First) /= '.' then
-- skip all files who's names start with ".", namely "." and ".."
Ada.Text_IO.Put_Line(Spaces(2*Indention) & Simple_Name(Found)
& (if Dir then " (dir)" else ""));
if Dir then
Print_Tree(Full_Name(Found), Indention + 1);
end if;
end if;
end;
end loop;
end Print_Tree;
 
begin
Print_Tree(Ada.Directories.Current_Directory);
end Directory_Tree;
Output:
outer (dir)
  inner (dir)
    innermost (dir)
      file
      another
file
some

[edit] Batch File

Prints a tree of the current directory.

@tree %cd%

[edit] BBC BASIC

This creates a native Windows Tree View control:

      INSTALL @lib$+"WINLIB5"
ON ERROR SYS "MessageBox", @hwnd%, REPORT$, 0, 0 : QUIT
 
REM!WC Windows constants:
TVI_SORT = -65533
TVIF_TEXT = 1
TVM_INSERTITEM = 4352
TVS_HASBUTTONS = 1
TVS_HASLINES = 2
TVS_LINESATROOT = 4
 
REM. TV_INSERTSTRUCT
DIM tvi{hParent%, \
\ hInsertAfter%, \
\ mask%, \
\ hItem%, \
\ state%, \
\ stateMask%, \
\ pszText%, \
\ cchTextMax%, \
\ iImage%, \
\ iSelectedImage%,\
\ cChildren%, \
\ lParam% \
\ }
 
SYS "InitCommonControls"
hTree% = FN_createwindow("SysTreeView32", "", 0, 0, @vdu.tr%, @vdu.tb%, 0, \
\ TVS_HASLINES OR TVS_HASBUTTONS OR TVS_LINESATROOT, 0)
hroot% = FNinsertnode(0, "Root")
hchild1% = FNinsertnode(hroot%, "Child 1")
hchild2% = FNinsertnode(hroot%, "Child 2")
hchild11% = FNinsertnode(hchild1%, "Grandchild 1")
hchild12% = FNinsertnode(hchild1%, "Grandchild 2")
hchild21% = FNinsertnode(hchild2%, "Grandchild 3")
hchild22% = FNinsertnode(hchild2%, "Grandchild 4")
 
REPEAT
WAIT 1
UNTIL FALSE
END
 
DEF FNinsertnode(hparent%, text$)
LOCAL hnode%
text$ += CHR$0
 
tvi.hParent% = hparent%
tvi.hInsertAfter% = TVI_SORT
tvi.mask% = TVIF_TEXT
tvi.pszText% = !^text$
 
SYS "SendMessage", hTree%, TVM_INSERTITEM, 0, tvi{} TO hnode%
IF hnode% = 0 ERROR 100, "TVM_INSERTITEM failed"
SYS "InvalidateRect", hTree%, 0, 0
= hnode%

Visualize tree bbc.gif

[edit] C

Print a simple tree to standard output:

#include <stdio.h>
#include <stdlib.h>
 
typedef struct stem_t *stem;
struct stem_t { const char *str; stem next; };
 
void tree(int root, stem head)
{
static const char *sdown = " |", *slast = " `", *snone = " ";
struct stem_t col = {0, 0}, *tail;
 
for (tail = head; tail; tail = tail->next) {
printf("%s", tail->str);
if (!tail->next) break;
}
 
printf("--%d\n", root);
 
if (root <= 1) return;
 
if (tail && tail->str == slast)
tail->str = snone;
 
if (!tail) tail = head = &col;
else tail->next = &col;
 
while (root) { // make a tree by doing something random
int r = 1 + (rand() % root);
root -= r;
col.str = root ? sdown : slast;
 
tree(r, head);
}
 
tail->next = 0;
}
 
int main(int c, char**v)
{
int n;
if (c < 2 || (n = atoi(v[1])) < 0) n = 8;
 
tree(n, 0);
return 0;
}
Output:
--8
  `--8
     |--7
     |  |--3
     |  |  |--2
     |  |  |  `--2
     |  |  |     `--2
     |  |  |        |--1
     |  |  |        `--1
     |  |  `--1
     |  |--2
     |  |  |--1
     |  |  `--1
     |  |--1
     |  `--1
     `--1

[edit] D

Translation of: Haskell
import std.stdio, std.conv, std.algorithm, std.array;
 
struct Node(T) { T value; Node* left, right; }
 
string[] treeIndent(T)(in Node!T* t) pure nothrow @safe {
if (!t) return ["-- (null)"];
const tr = t.right.treeIndent;
return "--" ~ t.value.text ~
t.left.treeIndent.map!q{" |" ~ a}.array ~
(" `" ~ tr[0]) ~ tr[1 .. $].map!q{" " ~ a}.array;
}
 
void main () {
static N(T)(T v, Node!T* l=null, Node!T* r=null) {
return new Node!T(v, l, r);
}
 
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);
}
Output:
--1
  |--2
  |  |--4
  |  |  |--7
  |  |  |  |-- (null)
  |  |  |  `-- (null)
  |  |  `-- (null)
  |  `--5
  |     |-- (null)
  |     `-- (null)
  `--3
     |--6
     |  |--8
     |  |  |-- (null)
     |  |  `-- (null)
     |  `--9
     |     |-- (null)
     |     `-- (null)
     `-- (null)

[edit] Erlang

Until real code shows up, I follow the lead of Python and print tuples with a width of 1.

Output:
9> io:fwrite("~1p", [{1, 2, {30, 40}, {{500, 600}, 70}}]).
{1,
 2,
 {30,
  40},
 {{500,
   600},
  70}}

[edit] F#

type tree =
| T of string * tree list
 
let prefMid = seq { yield "├─"; while true do yield "│ " }
let prefEnd = seq { yield "└─"; while true do yield " " }
let prefNone = seq { while true do yield "" }
 
let c2 x y = Seq.map2 (fun u v -> String.concat "" [u; v]) x y
 
let rec visualize (T(label, children)) pre =
seq {
yield (Seq.head pre) + label
if children <> [] then
let preRest = Seq.skip 1 pre
let last = Seq.last (List.toSeq children)
for e in children do
if e = last then yield! visualize e (c2 preRest prefEnd)
else yield! visualize e (c2 preRest prefMid)
}
 
let example =
T ("root",
[T ("a",
[T ("a1",
[T ("a11", []);
T ("a12", []) ]) ]);
T ("b",
[T ("b1", []) ]) ])
 
visualize example prefNone
|> Seq.iter (printfn "%s")
Output:
root
├─a
│ └─a1
│   ├─a11
│   └─a12
└─b
  └─b1

[edit] Go

[edit] 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.

package main
 
import (
"encoding/json"
"fmt"
"log"
)
 
type Node struct {
Name string
Children []*Node
}
 
func main() {
tree := &Node{"root", []*Node{
&Node{"a", []*Node{
&Node{"d", nil},
&Node{"e", []*Node{
&Node{"f", nil},
}}}},
&Node{"b", nil},
&Node{"c", nil},
}}
b, err := json.MarshalIndent(tree, "", " ")
if err != nil {
log.Fatal(err)
}
fmt.Println(string(b))
}
Output:
{
   "Name": "root",
   "Children": [
      {
         "Name": "a",
         "Children": [
            {
               "Name": "d",
               "Children": null
            },
            {
               "Name": "e",
               "Children": [
                  {
                     "Name": "f",
                     "Children": null
                  }
               ]
            }
         ]
      },
      {
         "Name": "b",
         "Children": null
      },
      {
         "Name": "c",
         "Children": null
      }
   ]
}

[edit] 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.

package main
 
import (
"log"
"os"
 
"github.com/BurntSushi/toml"
)
 
type Node struct {
Name string
Children []*Node
}
 
func main() {
tree := &Node{"root", []*Node{
&Node{"a", []*Node{
&Node{"d", nil},
&Node{"e", []*Node{
&Node{"f", nil},
}}}},
&Node{"b", nil},
&Node{"c", nil},
}}
enc := toml.NewEncoder(os.Stdout)
enc.Indent = " "
err := enc.Encode(tree)
if err != nil {
log.Fatal(err)
}
}
Output:
Name = "root"

[[Children]]
   Name = "a"

   [[Children.Children]]
      Name = "d"


   [[Children.Children]]
      Name = "e"

      [[Children.Children.Children]]
         Name = "f"


[[Children]]
   Name = "b"


[[Children]]
   Name = "c"

[edit] Haskell

Tree borrowed from Tree traversal:

data Tree a = Empty | Node { value :: a, left :: Tree a, right :: Tree a }
deriving (Show, Eq)
 
tree = Node 1 (Node 2 (Node 4 (Node 7 Empty Empty) Empty)
(Node 5 Empty Empty)) (Node 3 (Node 6 (Node 8 Empty Empty)
(Node 9 Empty Empty)) Empty)
 
treeIndent Empty = ["-- (nil)"]
treeIndent t = ["--" ++ show (value t)]
++ map (" |"++) ls ++ (" `" ++ r):map (" "++) rs
where
(r:rs) = treeIndent$right t
ls = treeIndent$left t
 
main = mapM_ putStrLn $ treeIndent tree
Output:
--1
  |--2
  |  |--4
  |  |  |--7
  |  |  |  |-- (nil)
  |  |  |  `-- (nil)
  |  |  `-- (nil)
  |  `--5
  |     |-- (nil)
  |     `-- (nil)
  `--3
     |--6
     |  |--8
     |  |  |-- (nil)
     |  |  `-- (nil)
     |  `--9
     |     |-- (nil)
     |     `-- (nil)
     `-- (nil)

[edit] Icon and Unicon

The following works in both languages.

procedure main(A)
showTree("", " -", [1, [2,[3],[4,[5],[6]],[7,[11]]], [8,[9,[10]]] ])
write()
showTree("", " -", [1, [2,[3,[4]]], [5,[6],[7,[8],[9]],[10]] ])
end
 
procedure showTree(prefix, lastc, A)
write(prefix, lastc, "--", A[1])
if *A > 1 then {
prefix ||:= if prefix[-1] == "|" then " " else " "
every showTree(prefix||"|", "-", !A[2:2 < *A])
showTree(prefix, "`-", A[*A])
}
end

Output:

->tree
 ---1
    |---2
    |   |---3
    |   |---4
    |   |   |---5
    |   |   `---6
    |   `---7
    |       `---11
    `---8
        `---9
            `---10

 ---1
    |---2
    |   `---3
    |       `---4
    `---5
        |---6
        |---7
        |   |---8
        |   `---9
        `---10
->

[edit] J

See: j:Essays/Tree Display

[edit] Java

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

public class VisualizeTree {
public static void main(String[] args) {
BinarySearchTree tree = new BinarySearchTree();
 
tree.insert(100);
for (int i = 0; i < 20; i++)
tree.insert((int) (Math.random() * 200));
tree.display();
}
}
 
class BinarySearchTree {
private Node root;
 
private class Node {
private int key;
private Node left, right;
 
Node(int k) {
key = k;
}
}
 
public boolean insert(int key) {
if (root == null)
root = new Node(key);
else {
Node n = root;
Node parent;
while (true) {
if (n.key == key)
return false;
 
parent = n;
 
boolean goLeft = key < n.key;
n = goLeft ? n.left : n.right;
 
if (n == null) {
if (goLeft) {
parent.left = new Node(key);
} else {
parent.right = new Node(key);
}
break;
}
}
}
return true;
}
 
public void display() {
final int height = 5, width = 64;
 
int len = width * height * 2 + 2;
StringBuilder sb = new StringBuilder(len);
for (int i = 1; i <= len; i++)
sb.append(i < len - 2 && i % width == 0 ? "\n" : ' ');
 
displayR(sb, width / 2, 1, width / 4, width, root, " ");
System.out.println(sb);
}
 
private void displayR(StringBuilder sb, int c, int r, int d, int w, Node n,
String edge) {
if (n != null) {
displayR(sb, c - d, r + 2, d / 2, w, n.left, " /");
 
String s = String.valueOf(n.key);
int idx1 = r * w + c - (s.length() + 1) / 2;
int idx2 = idx1 + s.length();
int idx3 = idx1 - w;
if (idx2 < sb.length())
sb.replace(idx1, idx2, s).replace(idx3, idx3 + 2, edge);
 
displayR(sb, c + d, r + 2, d / 2, w, n.right, "\\ ");
}
}
}
                             100                              
                /                              \               
               49                              106             
        /              \                /              \       
       44              94              105             152     
    /      \        /                               /      \   
   26      47      61                              109     178 
  /  \            /  \                               \    /    
 12  33          51  88                              119 159

[edit] JavaScript

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

<!doctype html>
<html id="doc">
<head><meta charset="utf-8"/>
<title>Stuff</title>
<script type="application/javascript">
function gid(id) { return document.getElementById(id); }
 
function ce(tag, cls, parent_node) {
var e = document.createElement(tag);
e.className = cls;
if (parent_node) parent_node.appendChild(e);
return e;
}
 
function dom_tree(id) {
gid('tree').textContent = "";
gid('tree').appendChild(mktree(gid(id), null));
}
 
function mktree(e, p) {
var t = ce("div", "tree", p);
var tog = ce("span", "toggle", t);
var h = ce("span", "tag", t);
 
if (e.tagName === undefined) {
h.textContent = "#Text";
var txt = e.textContent;
if (txt.length > 0 && txt.match(/\S/)) {
h = ce("div", "txt", t);
h.textContent = txt;
}
return t;
}
 
tog.textContent = "−";
tog.onclick = function () { clicked(tog); }
h.textContent = e.nodeName;
 
var l = e.childNodes;
for (var i = 0; i != l.length; i++)
mktree(l[i], t);
return t;
}
 
function clicked(e) {
var is_on = e.textContent == "−";
e.textContent = is_on ? "+" : "−";
e.parentNode.className = is_on ? "tree-hide" : "tree";
}
</script>
<style>
#tree { white-space: pre; font-family: monospace; border: 1px solid }
.tree > .tree-hide, .tree > .tree
{ margin-left: 2em; border-left: 1px dotted rgba(0,0,0,.2)}
.tree-hide > .tree, .tree-hide > .tree-hide { display: none }
.tag { color: navy }
.tree-hide > .tag { color: maroon }
.txt { color: gray; padding: 0 .5em; margin: 0 .5em 0 2em; border: 1px dotted rgba(0,0,0,.1) }
.toggle { display: inline-block; width: 2em; text-align: center }
</style>
</head>
<body>
<article>
<section>
<h1>Headline</h1>
Blah blah
</section>
<section>
<h1>More headline</h1>
<blockquote>Something something</blockquote>
<section><h2>Nested section</h2>
Somethin somethin list:
<ul>
<li>Apples</li>
<li>Oranges</li>
<li>Cetera Fruits</li>
</ul>
</section>
</section>
</article>
<div id="tree"><a href="javascript:dom_tree('doc')">click me</a></div>
</body>
</html>

[edit] Mathematica

[edit] Tree graph

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

edges = {1 \[DirectedEdge] 2, 1 \[DirectedEdge] 3, 2 \[DirectedEdge] 4, 2 \[DirectedEdge] 5, 
3 \[DirectedEdge] 6, 4 \[DirectedEdge] 7};
t = TreeGraph[edges, GraphStyle -> "VintageDiagram"]
Tree.jpg

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

TreeForm[Defer@
TreeGraph[{1 \[DirectedEdge] 2, 1 \[DirectedEdge] 3, 2 \[DirectedEdge] 4, 2 \[DirectedEdge] 5,
3 \[DirectedEdge] 6, 4 \[DirectedEdge] 7}, VertexLabels -> "Name"]]

Syntax.jpg

[edit] Opener view

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

OpenerView[{1, Column@{OpenerView[{2, Column@{OpenerView[{4, 7}, True], 5}}, True],
OpenerView[{3, OpenerView[{TraditionalForm[Cos[x]], Plot[Cos[x], {x, 0, 10}, ImageSize -> 150]},
True]}, True]}}, True]

Opener.jpg

[edit] Maxima

load(graphs)$
 
g: random_tree(10)$
 
is_tree(g);
true
 
draw_graph(g)$

[edit] Nimrod

Translation of: Haskell
import strutils
 
type
Node[T] = ref TNode[T]
TNode[T] = object
data: T
left, right: Node[T]
 
proc n[T](data: T; left, right: Node[T] = nil): Node[T] =
Node[T](data: data, left: left, right: right)
 
proc indent[T](n: Node[T]): seq[string] =
if n == nil: return @["-- (null)"]
 
result = @["--" & $n.data]
 
for a in indent n.left: result.add " |" & a
 
let r = indent n.right
result.add " `" & r[0]
for a in r[1..r.high]: result.add " " & a
 
let tree = 1.n(2.n(4.n(7.n),5.n),3.n(6.n(8.n,9.n)))
 
echo tree.indent.join("\n")

[edit] Perl

#!/usr/bin/perl
use warnings;
use strict;
use utf8;
use open OUT => ':utf8', ':std';
 
sub parse {
my ($tree) = shift;
if (my ($root, $children) = $tree =~ /^(.+?)\((.*)\)$/) {
 
my $depth = 0;
for my $pos (0 .. length($children) - 1) {
my $char = \substr $children, $pos, 1;
if (0 == $depth and ',' eq $$char) {
$$char = "\x0";
} elsif ('(' eq $$char) {
$depth++;
} elsif (')' eq $$char) {
$depth--;
}
}
return($root, [map parse($_), split /\x0/, $children]);
 
} else { # Leaf.
return $tree;
}
}
 
sub output {
my ($parsed, $prefix) = @_;
my $is_root = not defined $prefix;
$prefix //= ' ';
while (my $member = shift @$parsed) {
my $last = !@$parsed || (1 == @$parsed and ref $parsed->[0]);
unless ($is_root) {
substr $prefix, -3, 1, ' ';
substr($prefix, -4, 1) =~ s/├/│/;
substr $prefix, -2, 1, ref $member ? ' ' : '└' if $last;
}
 
if (ref $member) {
output($member, $prefix . '├─');
} else {
print $prefix, $member, "\n";
}
}
}
 
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)];
output($parsed);
Output:
 a
 ├─b0
 │ ├─c1
 │ ├─c2
 │ │ └─d
 │ │   ├─ef
 │ │   └─gh
 │ └─c3
 │   ├─i1
 │   ├─i2
 │   ├─i3
 │   │ └─jj
 │   └─i4
 │     ├─kk
 │     └─m
 └─b1
   ├─C1
   ├─C2
   │ ├─D1
   │ │ └─E
   │ ├─D2
   │ └─D3
   └─C3

[edit] Perl 6

sub visualize-tree($tree, &label, &children,
:$indent = '',
:@mid = ('├─', '│ '),
:@end = ('└─', ' '),
) {
sub visit($node, *@pre) {
gather {
take @pre[0] ~ label($node);
my @children := children($node);
my $end = @children.end;
for @children.kv -> $_, $child {
when $end { take visit($child, (@pre[1] X~ @end)) }
default { take visit($child, (@pre[1] X~ @mid)) }
}
}
}
visit($tree, $indent xx 2);
}
 
# example tree built up of pairs
my $tree = root=>[a=>[a1=>[a11=>[]]],b=>[b1=>[b11=>[]],b2=>[],b3=>[]]];
 
.say for visualize-tree($tree, *.key, *.value.list);
Output:
root
├─a
│ └─a1
│   └─a11
└─b
  ├─b1
  │ └─b11
  ├─b2
  └─b3

[edit] PicoLisp

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

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

Output:

+-- 1
|
+---+-- 2
|   |
|   +---+-- 3
|   |   |
|   |   +---+-- 4
|   |   |
|   |   +---+-- 5
|   |   |
|   |   +---+-- 6
|   |       |
|   |       +---+-- 7
|   |
|   +---+-- 8
|   |   |
|   |   +---+-- 9
|   |
|   +---+-- 10
|
+---+-- 11
    |
    +---+-- 12
    |
    +---+-- 13

[edit] Prolog

[edit] XPCE

XPCE is the SWI-Prolog native GUI library.

% direction may be horizontal/vertical/list
display_tree(Direction) :-
sformat(A, 'Display tree ~w', [Direction]),
new(D, window(A)),
send(D, size, size(350,200)),
new(T, tree(text('Root'))),
send(T, neighbour_gap, 10),
new(S1, node(text('Child1'))),
new(S2, node(text('Child2'))),
send_list(T, son,[S1,S2]),
new(S11, node(text('Grandchild1'))),
new(S12, node(text('Grandchild2'))),
send_list(S1, son, [S11, S12]),
new(S21, node(text('Grandchild3'))),
new(S22, node(text('Grandchild4'))),
send_list(S2, son, [S21, S22]),
send(T, direction, Direction),
send(D, display, T),
send(D, open).
 

Display tree.png

[edit] Python

Python has the pprint module for pretty-printing data.

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:

Python 3.2.3 (default, May  3 2012, 15:54:42) 
[GCC 4.6.3] on linux2
Type "copyright", "credits" or "license()" for more information.
>>> help('pprint.pprint')
Help on function pprint in pprint:
 
pprint.pprint = pprint(object, stream=None, indent=1, width=80, depth=None)
Pretty-print a Python object to a stream [default is sys.stdout].
 
>>> from pprint import pprint
>>> for tree in [ (1, 2, 3, 4, 5, 6, 7, 8),
(1, (( 2, 3 ), (4, (5, ((6, 7), 8))))),
((((1, 2), 3), 4), 5, 6, 7, 8) ]:
print("\nTree %r can be pprint'd as:" % (tree, ))
pprint(tree, indent=1, width=1)
 
 
 
Tree (1, 2, 3, 4, 5, 6, 7, 8) can be pprint'd as:
(1,
2,
3,
4,
5,
6,
7,
8)
 
Tree (1, ((2, 3), (4, (5, ((6, 7), 8))))) can be pprint'
d as:
(1,
((2,
3),
(4,
(5,
((6,
7),
8)))))
 
Tree ((((1, 2), 3), 4), 5, 6, 7, 8) can be pprint'd as:
((((1,
2),
3),
4),
5,
6,
7,
8)
>>>

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

>>> tree = "a",("b0",("c1","c2",("d",("ef","gh")),"c3",("i1","i2","i3",("jj"),"i4",("kk","m"))),"b1",("C1","C2",("D1",("E"),"D2","D3"),"C3"))
>>> pprint(tree, width=1)
('a',
('b0',
('c1',
'c2',
('d',
('ef',
'gh')),
'c3',
('i1',
'i2',
'i3',
'jj',
'i4',
('kk',
'm'))),
'b1',
('C1',
'C2',
('D1',
'E',
'D2',
'D3'),
'C3')))
>>> copypasteoutput = ('a',
... ('b0',
... ('c1',
... 'c2',
... ('d',
... ('ef',
... 'gh')),
... 'c3',
... ('i1',
... 'i2',
... 'i3',
... 'jj',
... 'i4',
... ('kk',
... 'm'))),
... 'b1',
... ('C1',
... 'C2',
... ('D1',
... 'E',
... 'D2',
... 'D3'),
... 'C3')))
>>> tree == copypasteoutput
True
>>>

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

>>> pprint(tree, width=60)
('a',
('b0',
('c1',
'c2',
('d', ('ef', 'gh')),
'c3',
('i1', 'i2', 'i3', 'jj', 'i4', ('kk', 'm'))),
'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:

>>> mixedtree = ['a', ('b0', ('c1', 'c2', ['d', ('ef', 'gh')], 'c3', ('i1', 'i2', 
... 'i3', 'jj', 'i4', ['kk', 'm'])), 'b1', ('C1', 'C2', ('D1', 'E',
... 'D2', 'D3'), 'C3'))]
>>> pprint(mixedtree, width=1)
['a',
('b0',
('c1',
'c2',
['d',
('ef',
'gh')],
'c3',
('i1',
'i2',
'i3',
'jj',
'i4',
['kk',
'm'])),
'b1',
('C1',
'C2',
('D1',
'E',
'D2',
'D3'),
'C3'))]
>>> pprint(mixedtree, width=60)
['a',
('b0',
('c1',
'c2',
['d', ('ef', 'gh')],
'c3',
('i1', 'i2', 'i3', 'jj', 'i4', ['kk', 'm'])),
'b1',
('C1', 'C2', ('D1', 'E', 'D2', 'D3'), 'C3'))]
>>>

[edit] Racket

 
#lang racket/base
 
(define (visualize t0)
(let loop ([t t0] [last? #t] [indent '()])
(define (I mid last) (cond [(eq? t t0) ""] [last? mid] [else last]))
(for-each display (reverse indent))
(unless (eq? t t0) (printf "|\n"))
(for-each display (reverse indent))
(printf "~a~a\n" (I "\\-" "+-") (car t))
(for ([s (cdr t)] [n (in-range (- (length t) 2) -1 -1)])
(loop s (zero? n) (cons (I " " "| ") indent)))))
 
(visualize '(1 (2 (3 (4) (5) (6 (7))) (8 (9)) (10)) (11 (12) (13))))
 

Output:

1
|
+-2
| |
| +-3
| | |
| | +-4
| | |
| | +-5
| | |
| | \-6
| |   |
| |   \-7
| |
| +-8
| | |
| | \-9
| |
| \-10
|
\-11
  |
  +-12
  |
  \-13

[edit] REXX

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

Call mktree
Say node.1.0name
Call tt 1,''
Exit
 
tt: Procedure Expose node.
/**********************************************************************
* show a subtree (recursively)
**********************************************************************/

Parse Arg k,st
Do i=1 To node.k.0
If i=node.k.0 Then
s='`--'
Else
s='|--'
c=node.k.i
If st<>'' Then
st=left(st,length(st)-2)' '
st=repl(st,' ','` ')
Say st||s||node.c.0name
Call tt c,st||s
End
Return
Exit
 
mktree: Procedure Expose node. root
/**********************************************************************
* build the tree according to the task
**********************************************************************/

node.=0
r=mknode('R');
a=mknode('A'); Call attchild a,r
b=mknode('B'); Call attchild b,a
c=mknode('C'); Call attchild c,a
d=mknode('D'); Call attchild d,b
e=mknode('E'); Call attchild e,b
f=mknode('F'); Call attchild f,b
g=mknode('G'); Call attchild g,b
h=mknode('H'); Call attchild h,d
i=mknode('I'); Call attchild i,h
j=mknode('J'); Call attchild j,i
k=mknode('K'); Call attchild k,j
l=mknode('L'); Call attchild l,j
m=mknode('M'); Call attchild m,e
n=mknode('N'); Call attchild n,e
Return
 
mknode: Procedure Expose node.
/**********************************************************************
* create a new node
**********************************************************************/

Parse Arg name
z=node.0+1
node.z.0name=name
node.0=z
Return z /* number of the node just created */
 
attchild: Procedure Expose node.
/**********************************************************************
* make a the next child of father
**********************************************************************/

Parse Arg a,father
node.a.0father=father
z=node.father.0+1
node.father.z=a
node.father.0=z
node.a.0level=node.father.0level+1
Return
Output:
R
`--A
   |--B
   |  |--D
   |  |  `--H
   |  |     `--I
   |  |        `--J
   |  |           |--K
   |  |           `--L
   |  |--E
   |  |  |--M
   |  |  `--N
   |  |--F
   |  `--G
   `--C

[edit] 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:

Output:
  #<BinaryTreeNode:0x804f854
   @left=
    #<BinaryTreeNode:0x804fad8
     @left=#<BinaryTreeNode:0x804fc28 @left=nil, @right=nil, @value=7>,
     @right=nil,
     @value=4>,
   @right=#<BinaryTreeNode:0x804f9c0 @left=nil, @right=nil, @value=5>,
   @value=2>,
 @right=
  #<BinaryTreeNode:0x804f074
   @left=
    #<BinaryTreeNode:0x804f218
     @left=#<BinaryTreeNode:0x804f544 @left=nil, @right=nil, @value=8>,
     @right=#<BinaryTreeNode:0x804f384 @left=nil, @right=nil, @value=9>,
     @value=6>,
   @right=nil,
   @value=3>,
 @value=1>

[edit] Tcl

Library: Tcllib (Package: struct::tree)
package require struct::tree
 
proc visualize_tree {tree {nameattr name}} {
set path {}
$tree walk [$tree rootname] -order both {mode node} {
if {$mode eq "enter"} {
set s ""
foreach p $path {
append s [expr {[$tree next $p] eq "" ? " " : "\u2502 "}]
}
lappend path $node
append s [expr {
[$tree next $node] eq "" ? "\u2514\u2500" : "\u251c\u2500"
}]
if {[$tree keyexists $node $nameattr]} {
set name [$tree get $node $nameattr]
} else {
# No node name attribute; use the raw name
set name $node
}
puts "$s$name"
} else {
set path [lrange $path 0 end-1]
}
}
}

Demonstrating:

# Sample tree to demonstrate with
struct::tree t deserialize {root {} {} a 0 {} d 3 {} e 3 {} f 9 {} b 0 {} c 0 {}}
visualize_tree t
Output:
└─root
  ├─a
  │ ├─d
  │ └─e
  │   └─f
  ├─b
  └─c

[edit] zkl

In zkl, the Vault is a global object store object (aka thread safe dictionary). Basically a tiny file system for objects. It has a "dir" method to display the contents

Output:
:Vault.dir()
...
Compiler
   Asm
   Compiler
Dictionary
Exception
Test
   UnitTester
   foo
      bar
...

It does this with data that looks like: L("Network.TCPServerSocket","File","ZKLShell.Granny","Int","startup","Utils.Inspector","Thread.Straw","Ref","Utils.Argh" ...)

fcn vaultDir(out=Console){
const INDENT=" ";
space:=""; lastPath:=L();
foreach fullname in (TheVault.BaseClass.contents.sort()){
path:=fullname.split("."); name:=path.pop();
if(lastPath==path) out.writeln(space,name);
else{
n:=0; p:=path.copy();
try{
while(path[0]==lastPath[0])
{ n+=1; path.pop(0); lastPath.pop(0); }
}catch{}
space=INDENT*n;
foreach dir in (path){ out.writeln(space,dir); space+=INDENT; }
out.writeln(space,name);
lastPath=p;
}
}
"" // so startup has something to display
}
 
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox