Content added Content deleted

Inline

Revision as of 06:46, 25 September 2012

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.

C

Print a simple tree to standard output: <lang c>#include <stdio.h>

include <stdlib.h>

typedef struct stem_t *stem; struct stem_t { char *str; stem next; };

void tree(int root, stem head) { static 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; }</lang>

Output:

--8
  `--8
     |--7
     |  |--3
     |  |  |--2
     |  |  |  `--2
     |  |  |     `--2
     |  |  |        |--1
     |  |  |        `--1
     |  |  `--1
     |  |--2
     |  |  |--1
     |  |  `--1
     |  |--1
     |  `--1
     `--1

D

Translation of: Haskell

<lang d>import std.stdio, std.conv, std.algorithm, std.array;

struct BTNode(T) {

   T value;
   typeof(this)* left, right;

}

string[] treeIndent(T)(in BTNode!T* t) {

   if (t is null) return ["-- (null)"];
   const tr = treeIndent(t.right);
   return text("--", t.value) ~
          map!q{"  |" ~ a}(treeIndent(t.left)).array() ~
          ("  `" ~ tr[0]) ~ map!q{"   " ~ a}(tr[1..$]).array();

}

void main () {

   static N(T)(T value_, BTNode!T* left_=null, BTNode!T* right_=null) {
       //return new BTNode!T(value_, left_, right_); // not supported
       auto t = new BTNode!T;
       *t = BTNode!T(value_, left_, right_);
       return t;
   }

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

}</lang>

Output:

--1
  |--2
  |  |--4
  |  |  |--7
  |  |  |  |-- (null)
  |  |  |  `-- (null)
  |  |  `-- (null)
  |  `--5
  |     |-- (null)
  |     `-- (null)
  `--3
     |--6
     |  |--8
     |  |  |-- (null)
     |  |  `-- (null)
     |  `--9
     |     |-- (null)
     |     `-- (null)
     `-- (null)

Haskell

Tree borrowed from Tree traversal: <lang haskell>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</lang>

Output:

--1
  |--2
  |  |--4
  |  |  |--7
  |  |  |  |-- (nil)
  |  |  |  `-- (nil)
  |  |  `-- (nil)
  |  `--5
  |     |-- (nil)
  |     `-- (nil)
  `--3
     |--6
     |  |--8
     |  |  |-- (nil)
     |  |  `-- (nil)
     |  `--9
     |     |-- (nil)
     |     `-- (nil)
     `-- (nil)

J

See: j:Essays/Tree Display

JavaScript

Javascript wrapped in HTML5 document. Should work in modern browsers. <lang html><!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>

Headline

       Blah blah

More headline

Something something

Nested section

Somethin somethin list:

Apples
Oranges
Cetera Fruits

     </section>
   </article>

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

 </body>

</html></lang>

Maxima

<lang maxima>load(graphs)$

g: random_tree(10)$

is_tree(g); true

draw_graph(g)$</lang>

Python

Python has the pprint module for pretty-printing data. <lang python>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)

>>> </lang>

Tcl

Library: Tcllib (Package: struct::tree)

<lang tcl>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] }

}</lang> Demonstrating: <lang tcl># 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</lang>

Output:

└─root
  ├─a
  │ ├─d
  │ └─e
  │   └─f
  ├─b
  └─c

Revision as of 12:38, 24 September 2012 (view source) rosettacode>Dkf (→‎Tcl: Added implementation) ← Older edit		Revision as of 06:46, 25 September 2012 (view source) rosettacode>Ledrug (promoted: no issues raised, plenty of examples, should be ok) Newer edit →
Line 1:		Line 1:
	{{~~draft~~ task}}		{{task}}
	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 <code>tree</code> command), nested HTML tables, hierarchical GUI widgets, 2D or 3D images, etc.		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 <code>tree</code> command), nested HTML tables, hierarchical GUI widgets, 2D or 3D images, etc.