Visualize a tree: Difference between revisions
+ D |
|||
Line 162: | Line 162: | ||
See: [[j:Essays/Tree Display]] |
See: [[j:Essays/Tree Display]] |
||
=={{header|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> |
|||
<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></lang> |
|||
=={{header|Maxima}}== |
=={{header|Maxima}}== |
Revision as of 23:37, 9 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
<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
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
<section>
Nested section
Somethin somethin list:
- Apples
- Oranges
- Cetera Fruits
</section> </article>
</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>