Visualize a tree

From Rosetta Code
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.

11l

Translation of: D
T Node
   String value
   Node? left
   Node? right

   F (value, Node? left = N, Node? right = N)
      .value = String(value)
      .left = left
      .right = right

   F tree_indent() -> [String]
      V tr = I .right != N {.right.tree_indent()} E [‘-- (null)’]
      R [‘--’(.value)] [+] (I .left != N {.left.tree_indent()} E [‘-- (null)’]).map(a -> ‘  |’a)
                       [+] [‘  `’tr[0]] + tr[1..].map(a -> ‘   ’a)

V tree = Node(1, Node(2, Node(4, Node(7)), Node(5)), Node(3, Node(6, Node(8), Node(9))))
print(tree.tree_indent().join("\n"))

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

ALGOL 68

# outputs nested html tables to visualise a tree #

# mode representing nodes of the tree #
MODE NODE = STRUCT( STRING value, REF NODE child, REF NODE sibling );
REF  NODE nil node = NIL;

# tags etc. #
STRING table = "<table border=""1"" cellspacing=""4"">"
     , elbat = "</table>"
     , tr    = "<tr>"
     , rt    = "</tr>"
     , td    = "<td style=""text-align: center; vertical-align: top; """
     , dt    = "</td>"
     , nbsp  = "&nbsp;"
     ;
CHAR   nl    = REPR 10;

# returns the number of child elements of tree #
OP CHILDCOUNT = ( REF NODE tree )INT:
    BEGIN
        INT      result := 0;
        REF NODE child  := child OF tree;
        WHILE REF NODE( child ) ISNT nil node
        DO
            result +:= 1;
            child   := sibling OF child
        OD;
        result
    END # CHILDCOUNT # ;

# generates nested HTML tables from the tree #
OP  TOHTML = ( REF NODE tree )STRING:
    IF tree IS nil node
    THEN
        # no node #
        ""
    ELSE
        # hae at least one node #
        STRING result     := "";
        INT    child count = CHILDCOUNT tree;
        result +:= table + nl
                 +   tr  + nl
                 +     td + " colspan="""
                          + whole( IF child count < 1 THEN 1 ELSE child count FI, 0 )
                          + """>" + nbsp + value OF tree + nbsp
                 +     dt + nl
                 +   rt  + nl
                 ;
        IF child count > 0
        THEN
            # the node has branches #
            REF NODE  child  := child OF tree;
            INT child number := 1;
            INT mid child     = ( child count + 1 ) OVER 2;
            child   := child OF tree;
            result +:= tr + nl;
            WHILE child ISNT nil node 
            DO
                result +:= td + ">" + nl
                         + IF CHILDCOUNT child < 1 THEN nbsp + value OF child + nbsp ELSE TOHTML child FI
                         + dt + nl;
                child := sibling OF child
            OD;
            result +:= rt + nl
        FI;
        result +:= elbat + nl
    FI # TOHTML # ;

# test the tree visualisation #

# returns a new node with the specified value and no child or siblings #
PROC new node = ( STRING value )REF NODE: HEAP NODE := NODE( value, nil node, nil node );
# appends a sibling node to the node n, returns the sibling #
OP +:= = ( REF NODE n, REF NODE sibling node )REF NODE:
    BEGIN
        REF NODE sibling := n;
        WHILE REF NODE( sibling OF sibling ) ISNT nil node
        DO
            sibling := sibling OF sibling
        OD;
        sibling OF sibling := sibling node
    END # +:= # ;
# appends a new sibling node to the node n, returns the sibling #
OP +:= = ( REF NODE n, STRING   sibling value )REF NODE: n +:= new node( sibling value );
# adds a child node to the node n, returns the child #
OP /:= = ( REF NODE n, REF NODE child node    )REF NODE: child OF n := child node;
# adda a new child node to the node n, returns the child #
OP /:= = ( REF NODE n, STRING   child value   )REF NODE: n /:= new node( child value );

NODE animals  := new node( "animals"  );
NODE fish     := new node( "fish"     );
NODE reptiles := new node( "reptiles" );
NODE mammals  := new node( "mammals"  );
NODE primates := new node( "primates" );
NODE sharks   := new node( "sharks"   );
sharks   /:= "great-white" +:= "hammer-head";
fish     /:= "cod"         +:= sharks           +:= "piranha";
reptiles /:= "iguana"      +:= "brontosaurus";
primates /:= "gorilla"     +:= "lemur";
mammals  /:= "sloth"       +:= "horse"          +:= "bison" +:= primates;
animals  /:= fish          +:= reptiles         +:= mammals;

print( ( TOHTML animals ) )
Output:
 animals 
 fish 
 cod 
 sharks 
 great-white   hammer-head 
 piranha 
 reptiles 
 iguana   brontosaurus 
 mammals 
 sloth   horse   bison 
 primates 
 gorilla   lemur 

AppleScript

Using UTF8 box-drawing characters in a monospaced font, with options for (1.) compacted vs vertically centered display, and (2.) retaining or pruning out nodeless lines of text.

Translation of: Python
Translation of: JavaScript
-- Vertically centered textual tree using UTF8 monospaced
-- box-drawing characters, with options for compacting
-- and pruning.

--               ┌── Gamma 
--       ┌─ Beta ┼── Delta 
--       │       └ Epsilon 
-- Alpha ┼─ Zeta ───── Eta 
--       │       ┌─── Iota 
--       └ Theta ┼── Kappa 
--               └─ Lambda 

-- TESTS --------------------------------------------------
on run
    set tree to Node(1, ¬
        {Node(2, ¬
            {Node(4, {Node(7, {})}), ¬
                Node(5, {})}), ¬
            Node(3, ¬
                {Node(6, ¬
                    {Node(8, {}), Node(9, {})})})})
    
    set tree2 to Node("Alpha", ¬
        {Node("Beta", ¬
            {Node("Gamma", {}), ¬
                Node("Delta", {}), ¬
                Node("Epsilon", {})}), ¬
            Node("Zeta", {Node("Eta", {})}), ¬
            Node("Theta", ¬
                {Node("Iota", {}), Node("Kappa", {}), ¬
                    Node("Lambda", {})})})
    
    set strTrees to unlines({"(NB – view in mono-spaced font)\n\n", ¬
        "Compacted (not all parents vertically centered):\n", ¬
        drawTree2(true, false, tree), ¬
        "\nFully expanded and vertically centered:\n", ¬
        drawTree2(false, false, tree2), ¬
        "\nVertically centered, with nodeless lines pruned out:\n", ¬
        drawTree2(false, true, tree2)})
    set the clipboard to strTrees
    strTrees
end run


-- drawTree2 :: Bool -> Bool -> Tree String -> String
on drawTree2(blnCompressed, blnPruned, tree)
    -- Tree design and algorithm inspired by the Haskell snippet at:
    -- https://doisinkidney.com/snippets/drawing-trees.html
    script measured
        on |λ|(t)
            script go
                on |λ|(x)
                    set s to " " & x & " "
                    Tuple(length of s, s)
                end |λ|
            end script
            fmapTree(go, t)
        end |λ|
    end script
    set measuredTree to |λ|(tree) of measured
    
    script levelMax
        on |λ|(a, level)
            a & maximum(map(my fst, level))
        end |λ|
    end script
    set levelWidths to foldl(levelMax, {}, ¬
        init(levels(measuredTree)))
    
    -- Lefts, Mid, Rights
    script lmrFromStrings
        on |λ|(xs)
            set {ls, rs} to items 2 thru -2 of ¬
                (splitAt((length of xs) div 2, xs) as list)
            Tuple3(ls, item 1 of rs, rest of rs)
        end |λ|
    end script
    
    script stringsFromLMR
        on |λ|(lmr)
            script add
                on |λ|(a, x)
                    a & x
                end |λ|
            end script
            foldl(add, {}, items 2 thru -2 of (lmr as list))
        end |λ|
    end script
    
    script fghOverLMR
        on |λ|(f, g, h)
            script
                property mg : mReturn(g)
                on |λ|(lmr)
                    set {ls, m, rs} to items 2 thru -2 of (lmr as list)
                    Tuple3(map(f, ls), |λ|(m) of mg, map(h, rs))
                end |λ|
            end script
        end |λ|
    end script
    
    script lmrBuild
        on leftPad(n)
            script
                on |λ|(s)
                    replicateString(n, space) & s
                end |λ|
            end script
        end leftPad
        
        -- lmrBuild main
        on |λ|(w, f)
            script
                property mf : mReturn(f)
                on |λ|(wsTree)
                    set xs to nest of wsTree
                    set lng to length of xs
                    set {nChars, x} to items 2 thru -2 of ¬
                        ((root of wsTree) as list)
                    set _x to replicateString(w - nChars, "─") & x
                    
                    -- LEAF NODE ------------------------------------
                    if 0 = lng then
                        Tuple3({}, _x, {})
                        
                    else if 1 = lng then
                        -- NODE WITH SINGLE CHILD ---------------------
                        set indented to leftPad(1 + w)
                        script lineLinked
                            on |λ|(z)
                                _x & "─" & z
                            end |λ|
                        end script
                        |λ|(|λ|(item 1 of xs) of mf) of ¬
                            (|λ|(indented, lineLinked, indented) of ¬
                                fghOverLMR)
                    else
                        -- NODE WITH CHILDREN -------------------------
                        script treeFix
                            on cFix(x)
                                script
                                    on |λ|(xs)
                                        x & xs
                                    end |λ|
                                end script
                            end cFix
                            
                            on |λ|(l, m, r)
                                compose(stringsFromLMR, ¬
                                    |λ|(cFix(l), cFix(m), cFix(r)) of ¬
                                    fghOverLMR)
                            end |λ|
                        end script
                        
                        script linked
                            on |λ|(s)
                                set c to text 1 of s
                                set t to tail(s)
                                if "┌" = c then
                                    _x & "┬" & t
                                else if "│" = c then
                                    _x & "┤" & t
                                else if "├" = c then
                                    _x & "┼" & t
                                else
                                    _x & "┴" & t
                                end if
                            end |λ|
                        end script
                        
                        set indented to leftPad(w)
                        set lmrs to map(f, xs)
                        if blnCompressed then
                            set sep to {}
                        else
                            set sep to {"│"}
                        end if
                        
                        tell lmrFromStrings
                            set tupleLMR to |λ|(intercalate(sep, ¬
                                {|λ|(item 1 of lmrs) of ¬
                                    (|λ|(" ", "┌", "│") of treeFix)} & ¬
                                map(|λ|("│", "├", "│") of treeFix, ¬
                                    init(tail(lmrs))) & ¬
                                {|λ|(item -1 of lmrs) of ¬
                                    (|λ|("│", "└", " ") of treeFix)}))
                        end tell
                        
                        |λ|(tupleLMR) of ¬
                            (|λ|(indented, linked, indented) of fghOverLMR)
                    end if
                end |λ|
            end script
        end |λ|
    end script
    
    set treeLines to |λ|(|λ|(measuredTree) of ¬
        foldr(lmrBuild, 0, levelWidths)) of stringsFromLMR
    if blnPruned then
        script notEmpty
            on |λ|(s)
                script isData
                    on |λ|(c)
                        "│ " does not contain c
                    end |λ|
                end script
                any(isData, characters of s)
            end |λ|
        end script
        set xs to filter(notEmpty, treeLines)
    else
        set xs to treeLines
    end if
    unlines(xs)
end drawTree2


-- GENERIC ------------------------------------------------

-- Node :: a -> [Tree a] -> Tree a
on Node(v, xs)
    {type:"Node", root:v, nest:xs}
end Node

-- Tuple (,) :: a -> b -> (a, b)
on Tuple(a, b)
    -- Constructor for a pair of values, possibly of two different types.
    {type:"Tuple", |1|:a, |2|:b, length:2}
end Tuple

-- Tuple3 (,,) :: a -> b -> c -> (a, b, c)
on Tuple3(x, y, z)
    {type:"Tuple3", |1|:x, |2|:y, |3|:z, length:3}
end Tuple3

-- Applied to a predicate and a list, 
-- |any| returns true if at least one element of the 
-- list satisfies the predicate.
-- any :: (a -> Bool) -> [a] -> Bool
on any(f, xs)
    tell mReturn(f)
        set lng to length of xs
        repeat with i from 1 to lng
            if |λ|(item i of xs) then return true
        end repeat
        false
    end tell
end any

-- compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
on compose(f, g)
    script
        property mf : mReturn(f)
        property mg : mReturn(g)
        on |λ|(x)
            |λ|(|λ|(x) of mg) of mf
        end |λ|
    end script
end compose

-- concat :: [[a]] -> [a]
-- concat :: [String] -> String
on concat(xs)
    set lng to length of xs
    if 0 < lng and string is class of (item 1 of xs) then
        set acc to ""
    else
        set acc to {}
    end if
    repeat with i from 1 to lng
        set acc to acc & item i of xs
    end repeat
    acc
end concat

-- concatMap :: (a -> [b]) -> [a] -> [b]
on concatMap(f, xs)
    set lng to length of xs
    set acc to {}
    tell mReturn(f)
        repeat with i from 1 to lng
            set acc to acc & (|λ|(item i of xs, i, xs))
        end repeat
    end tell
    return acc
end concatMap

-- filter :: (a -> Bool) -> [a] -> [a]
on filter(f, xs)
    tell mReturn(f)
        set lst to {}
        set lng to length of xs
        repeat with i from 1 to lng
            set v to item i of xs
            if |λ|(v, i, xs) then set end of lst to v
        end repeat
        return lst
    end tell
end filter

-- fmapTree :: (a -> b) -> Tree a -> Tree b
on fmapTree(f, tree)
    script go
        property g : |λ| of mReturn(f)
        on |λ|(x)
            set xs to nest of x
            if xs  {} then
                set ys to map(go, xs)
            else
                set ys to xs
            end if
            Node(g(root of x), ys)
        end |λ|
    end script
    |λ|(tree) of go
end fmapTree

-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
    tell mReturn(f)
        set v to startValue
        set lng to length of xs
        repeat with i from 1 to lng
            set v to |λ|(v, item i of xs, i, xs)
        end repeat
        return v
    end tell
end foldl

-- foldr :: (a -> b -> b) -> b -> [a] -> b
on foldr(f, startValue, xs)
    tell mReturn(f)
        set v to startValue
        set lng to length of xs
        repeat with i from lng to 1 by -1
            set v to |λ|(item i of xs, v, i, xs)
        end repeat
        return v
    end tell
end foldr

-- fst :: (a, b) -> a
on fst(tpl)
    if class of tpl is record then
        |1| of tpl
    else
        item 1 of tpl
    end if
end fst

-- identity :: a -> a
on identity(x)
    -- The argument unchanged.
    x
end identity

-- init :: [a] -> [a]
-- init :: [String] -> [String]
on init(xs)
    set blnString to class of xs = string
    set lng to length of xs
    
    if lng > 1 then
        if blnString then
            text 1 thru -2 of xs
        else
            items 1 thru -2 of xs
        end if
    else if lng > 0 then
        if blnString then
            ""
        else
            {}
        end if
    else
        missing value
    end if
end init

-- intercalate :: [a] -> [[a]] -> [a]
-- intercalate :: String -> [String] -> String
on intercalate(sep, xs)
    concat(intersperse(sep, xs))
end intercalate

-- intersperse(0, [1,2,3]) -> [1, 0, 2, 0, 3]
-- intersperse :: a -> [a] -> [a]
-- intersperse :: Char -> String -> String
on intersperse(sep, xs)
    set lng to length of xs
    if lng > 1 then
        set acc to {item 1 of xs}
        repeat with i from 2 to lng
            set acc to acc & {sep, item i of xs}
        end repeat
        if class of xs is string then
            concat(acc)
        else
            acc
        end if
    else
        xs
    end if
end intersperse

-- isNull :: [a] -> Bool
-- isNull :: String -> Bool
on isNull(xs)
    if class of xs is string then
        "" = xs
    else
        {} = xs
    end if
end isNull

-- iterateUntil :: (a -> Bool) -> (a -> a) -> a -> [a]
on iterateUntil(p, f, x)
    script
        property mp : mReturn(p)'s |λ|
        property mf : mReturn(f)'s |λ|
        property lst : {x}
        on |λ|(v)
            repeat until mp(v)
                set v to mf(v)
                set end of lst to v
            end repeat
            return lst
        end |λ|
    end script
    |λ|(x) of result
end iterateUntil

-- levels :: Tree a -> [[a]]
on levels(tree)
    script nextLayer
        on |λ|(xs)
            script
                on |λ|(x)
                    nest of x
                end |λ|
            end script
            concatMap(result, xs)
        end |λ|
    end script
    
    script roots
        on |λ|(xs)
            script
                on |λ|(x)
                    root of x
                end |λ|
            end script
            map(result, xs)
        end |λ|
    end script
    
    map(roots, iterateUntil(my isNull, nextLayer, {tree}))
end levels

-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
    -- The list obtained by applying f
    -- to each element of xs.
    tell mReturn(f)
        set lng to length of xs
        set lst to {}
        repeat with i from 1 to lng
            set end of lst to |λ|(item i of xs, i, xs)
        end repeat
        return lst
    end tell
end map

-- maximum :: Ord a => [a] -> a
on maximum(xs)
    script
        on |λ|(a, b)
            if a is missing value or b > a then
                b
            else
                a
            end if
        end |λ|
    end script
    foldl(result, missing value, xs)
end maximum

-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
    -- 2nd class handler function lifted into 1st class script wrapper. 
    if script is class of f then
        f
    else
        script
            property |λ| : f
        end script
    end if
end mReturn

-- replicateString :: Int -> String -> String
on replicateString(n, s)
    set out to ""
    if n < 1 then return out
    set dbl to s
    
    repeat while (n > 1)
        if (n mod 2) > 0 then set out to out & dbl
        set n to (n div 2)
        set dbl to (dbl & dbl)
    end repeat
    return out & dbl
end replicateString

-- snd :: (a, b) -> b
on snd(tpl)
    if class of tpl is record then
        |2| of tpl
    else
        item 2 of tpl
    end if
end snd

-- splitAt :: Int -> [a] -> ([a], [a])
on splitAt(n, xs)
    if n > 0 and n < length of xs then
        if class of xs is text then
            Tuple(items 1 thru n of xs as text, items (n + 1) thru -1 of xs as text)
        else
            Tuple(items 1 thru n of xs, items (n + 1) thru -1 of xs)
        end if
    else
        if n < 1 then
            Tuple({}, xs)
        else
            Tuple(xs, {})
        end if
    end if
end splitAt

-- tail :: [a] -> [a]
on tail(xs)
    set blnText to text is class of xs
    if blnText then
        set unit to ""
    else
        set unit to {}
    end if
    set lng to length of xs
    if 1 > lng then
        missing value
    else if 2 > lng then
        unit
    else
        if blnText then
            text 2 thru -1 of xs
        else
            rest of xs
        end if
    end if
end tail

-- unlines :: [String] -> String
on unlines(xs)
    -- A single string formed by the intercalation
    -- of a list of strings with the newline character.
    set {dlm, my text item delimiters} to ¬
        {my text item delimiters, linefeed}
    set str to xs as text
    set my text item delimiters to dlm
    str
end unlines
Output:
(NB – view in mono-spaced font)


Compacted (not all parents vertically centered):

       ┌ 4 ─ 7 
   ┌ 2 ┴ 5 
 1 ┤       ┌ 8 
   └ 3 ─ 6 ┴ 9 

Fully expanded and vertically centered:

               ┌── Gamma 
               │
       ┌─ Beta ┼── Delta 
       │       │
       │       └ Epsilon 
       │
 Alpha ┼─ Zeta ───── Eta 
       │
       │       ┌─── Iota 
       │       │
       └ Theta ┼── Kappa 
               │
               └─ Lambda 

Vertically centered, with nodeless lines pruned out:

               ┌── Gamma 
       ┌─ Beta ┼── Delta 
       │       └ Epsilon 
 Alpha ┼─ Zeta ───── Eta 
       │       ┌─── Iota 
       └ Theta ┼── Kappa 
               └─ Lambda 

Batch File

Displays a tree of the current directory.

@tree %cd%

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%

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

C++

#include <functional>
#include <iostream>
#include <random>

class BinarySearchTree {
private:
    struct Node {
        int key;
        Node *left, *right;

        Node(int k) : key(k), left(nullptr), right(nullptr) {
            //empty
        }
    } *root;

public:
    BinarySearchTree() : root(nullptr) {
        // empty
    }

    bool insert(int key) {
        if (root == nullptr) {
            root = new Node(key);
        } else {
            auto n = root;
            Node *parent;
            while (true) {
                if (n->key == key) {
                    return false;
                }

                parent = n;

                bool goLeft = key < n->key;
                n = goLeft ? n->left : n->right;

                if (n == nullptr) {
                    if (goLeft) {
                        parent->left = new Node(key);
                    } else {
                        parent->right = new Node(key);
                    }
                    break;
                }
            }
        }
        return true;
    }

    friend std::ostream &operator<<(std::ostream &, const BinarySearchTree &);
};

template<typename T>
void display(std::ostream &os, const T *n) {
    if (n != nullptr) {
        os << "Node(";

        display(os, n->left);

        os << ',' << n->key << ',';

        display(os, n->right);

        os << ")";
    } else {
        os << '-';
    }
}

std::ostream &operator<<(std::ostream &os, const BinarySearchTree &bst) {
    display(os, bst.root);
    return os;
}

int main() {
    std::default_random_engine generator;
    std::uniform_int_distribution<int> distribution(0, 200);
    auto rng = std::bind(distribution, generator);

    BinarySearchTree tree;

    tree.insert(100);
    for (size_t i = 0; i < 20; i++) {
        tree.insert(rng());
    }
    std::cout << tree << '\n';

    return 0;
}
Output:
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,-))

C#

using System;

public static class VisualizeTree
{
    public static void Main() {
        "A".t(
            "B0".t(
                "C1",
                "C2".t(
                    "D".t("E1", "E2", "E3")),
                "C3".t(
                    "F1",
                    "F2",
                    "F3".t("G"),
                    "F4".t("H1", "H2"))),
            "B1".t(
                "K1",
                "K2".t(
                    "L1".t("M"),
                    "L2",
                    "L3"),
                "K3")
        ).Print();
    }

    private static Tree t(this string value, params Tree[] children) => new Tree(value, children);

    private static void Print(this Tree tree) => tree.Print(true, "");

    private static void Print(this Tree tree, bool last, string prefix) {
        (string current, string next) = last
            ? (prefix + "└─" + tree.Value, prefix + "  ")
            : (prefix + "├─" + tree.Value, prefix + "| ");
        Console.WriteLine(current[2..]);
        for (int c = 0; c < tree.Children.Length; c++) {
            tree.Children[c].Print(c == tree.Children.Length - 1, next);
        }
    }

    class Tree
    {
        public Tree(string value, params Tree[] children) => (Value, Children) = (value, children);
        public static implicit operator Tree(string value) => new Tree(value);
        public string Value { get; }
        public Tree[] Children { get; }
    }
    
}
Output:
A
├─B0
| ├─C1
| ├─C2
| | └─D
| |   ├─E1
| |   ├─E2
| |   └─E3
| └─C3
|   ├─F1
|   ├─F2
|   ├─F3
|   | └─G
|   └─F4
|     ├─H1
|     └─H2
└─B1
  ├─K1
  ├─K2
  | ├─L1
  | | └─M
  | ├─L2
  | └─L3
  └─K3

Clojure

(use 'vijual)

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

Common Lisp

(defun visualize (tree)
  (labels
      ((rprint (list)
         (mapc #'princ (reverse list)))
       (vis-h (tree branches)
         (let ((len (length tree)))
           (loop
              for item in tree
              for idx from 1 to len do
                (cond
                  ((listp item)
                   (rprint (cdr branches))
                   (princ "+---+")
                   (let ((next (cons "|   "
                                     (if (= idx len)
                                         (cons "    " (cdr branches))
                                         branches))))
                     (terpri)
                     (rprint (if (null item)
                                 (cdr next)
                                 next))
                     (terpri)
                     (vis-h item next)))
                  (t
                   (rprint (cdr branches))
                   (princ item)
                   (terpri)
                   (rprint (if (= idx len)
                               (cdr branches)
                               branches))
                   (terpri)))))))
    (vis-h tree '("|   "))))
Output:
CL-USER> (visualize '(a b c ((d (e ((() ()))) f)) (g)))
A
|   
B
|   
C
|   
+---+
|   |   
|   +---+
|       |   
|       D
|       |   
|       +---+
|       |   |   
|       |   E
|       |   |   
|       |   +---+
|       |       |   
|       |       +---+
|       |           |   
|       |           +---+
|       |           |   
|       |           +---+
|       |               
|       F
|       
+---+
    |   
    G
    
NIL

or

(use-package :iterate)
(defun print-tree (tree value-function children-function)
  (labels
      ((do-print-tree (tree prefix)
         (format t "~a~%" (funcall value-function tree))
         (iter
           (with children = (funcall children-function tree))
           (for child = (pop children))
           (while child)
        
           (if children
               (progn (format t "~a├─ " prefix)
                      (do-print-tree child (format nil "~a│  " prefix)))
               (progn (format t "~a└─ " prefix)
                      (do-print-tree child (format nil "~a   " prefix)))))))
    (do-print-tree tree "")))
Output:
CL-USER>(print-tree '(a
              (aa
               (aaa
                (aaaa)
                (aaab
                 (aaaba)
                 (aaabb))
                (aaac)))
              (ab)
              (ac
               (aca)
               (acb)
               (acc)))
            #'car #'cdr)
A
├─ AA
  └─ AAA
     ├─ AAAA
     ├─ AAAB
       ├─ AAABA
       └─ AAABB
     └─ AAAC
├─ AB
└─ AC
   ├─ ACA
   ├─ ACB
   └─ ACC

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)

Delphi

Translation of: Go
program Visualize_a_tree;

{$APPTYPE CONSOLE}

uses
  System.SysUtils;

type
  TNode = record
    _label: string;
    children: TArray<Integer>;
  end;

  TTree = TArray<TNode>;

  TTreeHelper = record helper for TTree
    procedure AddNode(lb: string; chl: TArray<Integer> = []);
  end;

procedure Vis(t: TTree);

  procedure f(n: Integer; pre: string);
  begin
    var ch := t[n].children;
    if Length(ch) = 0 then
    begin
      Writeln('-', t[n]._label);
      exit;
    end;

    writeln('+', t[n]._label);
    var last := Length(ch) - 1;
    for var c in copy(ch, 0, last) do
    begin
      write(pre, '+-');
      f(c, pre + '¦ ');
    end;
    write(pre, '+-');
    f(ch[last], pre + '  ');
  end;

begin
  if Length(t) = 0 then
  begin
    writeln('<empty>');
    exit;
  end;

  f(0, '');
end;

{ TTreeHelper }

procedure TTreeHelper.AddNode(lb: string; chl: TArray<Integer> = []);
begin
  SetLength(self, Length(self) + 1);
  with self[High(self)] do
  begin
    _label := lb;
    if Length(chl) > 0 then
      children := copy(chl, 0, length(chl));
  end;
end;

var
  Tree: TTree;

begin
  Tree.AddNode('root', [1, 2, 3]);
  Tree.AddNode('ei', [4, 5]);
  Tree.AddNode('bee');
  Tree.AddNode('si');
  Tree.AddNode('dee');
  Tree.AddNode('y', [6]);
  Tree.AddNode('eff');

  Vis(Tree);

  {$IFNDEF UNIX} readln; {$ENDIF}
end.
Output:
┐root
├─┐ei
│ ├──dee
│ └─┐y
│   └──eff
├──bee
└──si

Elena

ELENA 5.0 :

import system'routines;
import extensions;

class Node
{
    string theValue;
    Node[] theChildren;
    
    constructor new(string value, Node[] children)
    {
        theValue := value;
                
        theChildren := children;
    }
    
    constructor new(string value)
        <= new(value, new Node[](0));
        
    constructor new(Node[] children)
        <= new(emptyString, children);
        
    get() = theValue;
    
    Children = theChildren;
}

extension treeOp
{
    writeTree(node, prefix)
    {
        var children := node.Children;
        var length := children.Length;
        
        children.zipForEach(new Range(1, length), (child,index)
        {
            self.printLine(prefix,"|");
            self.printLine(prefix,"+---",child.get());                
            
            var nodeLine := prefix + (index==length).iif("    ","|   ");
            
            self.writeTree(child,nodeLine);
        });
        
        ^ self
    }
    
    writeTree(node)
        = self.writeTree(node,"");
}

public program()
{
    var tree := Node.new(
                 new Node[]{
                    Node.new("a", new Node[]
                    {
                        Node.new("b", new Node[]{Node.new("c")}),
                        Node.new("d")
                    }),
                    Node.new("e")
                 });
                 
    console.writeTree(tree).readChar()
}
Output:
|
+---a
|   |
|   +---b
|   |   |
|   |   +---c
|   |
|   +---d
|
+---e

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

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

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 tab-size and margin for customizing the look of a tree. For smaller trees, it's best to change margin from its default of 64 to something low, perhaps 10.

USE: literals

CONSTANT: mammals { "mammals" { "deer" "gorilla" "dolphin" } }
CONSTANT: reptiles { "reptiles" { "turtle" "lizard" "snake" } }

{ "animals" ${ mammals reptiles } } dup . 10 margin set .
Output:
{
    "animals"
    {
        { "mammals" { "deer" "gorilla" "dolphin" } }
        { "reptiles" { "turtle" "lizard" "snake" } }
    }
}
{
    "animals"
    {
        {
            "mammals"
            {
                "deer"
                "gorilla"
                "dolphin"
            }
        }
        {
            "reptiles"
            {
                "turtle"
                "lizard"
                "snake"
            }
        }
    }
}

An example showcasing tuples by displaying an AVL tree:

USE: trees.avl
AVL{ { 1 2 } { 9 19 } { 3 4 } { 5 6 } } .
Output:
T{ avl
    { root
        T{ avl-node
            { key 3 }
            { value 4 }
            { left
                T{ avl-node
                    { key 1 }
                    { value 2 }
                    { balance 0 }
                }
            }
            { right
                T{ avl-node
                    { key 9 }
                    { value 19 }
                    { left
                        T{ avl-node
                            { key 5 }
                            { value 6 }
                            { balance 0 }
                        }
                    }
                    { balance -1 }
                }
            }
            { balance 1 }
        }
    }
    { count 4 }
}

Fōrmulæ

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website.

In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.

Solution

Fōrmulæ is a homoiconic language using expression trees as its fundamental structure, so managing trees is very natural.

Creating trees from expressions

The ToTree expression creates a tree from a given expression. see the following examples:

File:Fōrmulæ - Visualize a tree 01.png

File:Fōrmulæ - Visualize a tree 02.png

Be aware the the expression will be first reduced, like the following:

File:Fōrmulæ - Visualize a tree 03.png

File:Fōrmulæ - Visualize a tree 04.png

It order to avoid the reduction, the use of the Protect expression is recommended:

File:Fōrmulæ - Visualize a tree 05.png

File:Fōrmulæ - Visualize a tree 06.png

In the following example, it is shown that a matrix is a list containing (same cardinality) sublists:

File:Fōrmulæ - Visualize a tree 07.png

File:Fōrmulæ - Visualize a tree 08.png

In the following example, it is shown that, according to the Fōrmulæ arithmetic canon, a negative number is a Negative expression containing a Number expression:

File:Fōrmulæ - Visualize a tree 09.png

File:Fōrmulæ - Visualize a tree 10.png

Creating trees programatically

The tree, like any other expression in Fōrmulæ is a first-class citizen of the language. Fōrmulæ also supports high-order functions, so trees can be set as parameters of functions, or retrieved from functions.

The following example shows a function that produces a Fibonacci tree, a tree that shows the calls of a function that recursively calculates Fibonacci numbers:

FreeBASIC

Translation of: Yabasic
Dim Shared As Ubyte colores(4) => {7,13,14,3,2}

Sub showTree(n As Integer, A As String)
    Dim As Integer i, co = 0, b = 1, col
    Dim As String cs = Left(A, 1)
    
    If cs = "" Then Exit Sub
    
    Select Case cs
    Case "["
        co += 1 : showTree(n + 1, Right(A, Len(A) - 1))
        Exit Select
    Case "]"
        co -= 1 : showTree(n - 1, Right(A, Len(A) - 1))
        Exit Select
    Case Else
        For i = 2 To n
            Print "  ";
            co = n
        Next i
        Color colores(co) : Print !"\&hc0-"; cs
        showTree(n, Right(A, Len(A) - 1))
        Exit Select
    End Select
End Sub

Cls
showTree(0, "[1[2[3][4[5][6]][7]][8[9]]]")
Print !"\n\n\n"
showTree(0, "[1[2[3[4]]][5[6][7[8][9]]]]")
Sleep


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.

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

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"

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.

package main

import "fmt"

type tree []node

type node struct {
    label    string
    children []int // indexes into tree
}

func main() {
    vis(tree{
        0: node{"root", []int{1, 2, 3}},
        1: node{"ei", []int{4, 5}},
        2: node{"bee", nil},
        3: node{"si", nil},
        4: node{"dee", nil},
        5: node{"y", []int{6}},
        6: node{"eff", nil},
    })
}

func vis(t tree) {
    if len(t) == 0 {
        fmt.Println("<empty>")
        return
    }
    var f func(int, string)
    f = func(n int, pre string) {
        ch := t[n].children
        if len(ch) == 0 {
            fmt.Println("╴", t[n].label)
            return
        }
        fmt.Println("┐", t[n].label)
        last := len(ch) - 1
        for _, ch := range ch[:last] {
            fmt.Print(pre, "├─")
            f(ch, pre+"│ ")
        }
        fmt.Print(pre, "└─")
        f(ch[last], pre+"  ")
    }
    f(0, "")
}
Output:
┐ root
├─┐ ei
│ ├─╴ dee
│ └─┐ y
│   └─╴ eff
├─╴ bee
└─╴ si

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)


The Data.Tree module in the standard (GHC) libraries also includes a drawTree function for multiway (rose) trees of strings. We can fmap show over our tree of integers to derive a tree of strings, and apply `drawTree` to that.

import Data.Tree (Tree(..), drawTree)

tree :: Tree Int
tree =
  Node
    1
    [ Node 2 [Node 4 [Node 7 []], Node 5 []]
    , Node 3 [Node 6 [Node 8 [], Node 9 []]]
    ]

main :: IO ()
main = (putStrLn . drawTree . fmap show) tree
Output:
1
|
+- 2
|  |
|  +- 4
|  |  |
|  |  `- 7
|  |
|  `- 5
|
`- 3
   |
   `- 6
      |
      +- 8
      |
      `- 9

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

J

See: j:Essays/Tree Display for tree represented as label pairs.

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

BOXC=: 9!:6 ''    NB. box drawing characters
EW  =: {: BOXC    NB. east-west

showtree=: 4 : 0
 NB. y is parent index for each node (non-indices for root nodes)
 NB. x is label for each node 
 t=. (<EW,' ') ,@<@,:@,&":&.> x        NB. tree fragments
 c=. |:(#~ e./@|:);(~.,"0&.>(</. i.@#)) y
 while. +./ b=. ({.c)*.//.-.e.~/c do.
  i=. b#~.{.c                          NB. parents whose children are leaves
  j=. </./(({.c)e.i)#"1 c              NB. leaves grouped by parents
  t=. a: (;j)}t i}~ (i{t) subtree&.> j{&.><t
  c=. (-.({.c)e.i)#"1 c                NB. prune edges to leaves
 end.
 ;([: ,.&.>/ extend&.>)&> t -. a:
)

subtree=: 4 : 0
 p=. EW={."1 s=. >{.t=. graft y
 (<(>{.x) root p),(<(connect p),.s),}.t
)

graft=: 3 : 0
 n=. (-~ >./) #&> y
 f=. i.@(,&0)@#&.>@{.&.> y
 ,&.>/ y ,&> n$&.>f
)

connect=: 3 : 0
 b=. (+./\ *. +./\.) y
 c=. (b+2*y){' ',9 3 3{BOXC  NB. │ NS ├ E
 c=. (0{BOXC) (b i. 1)}c     NB. ┌ NW
 c=. (6{BOXC) (b i: 1)}c     NB. └ SW
 j=. (b i. 1)+<.-:+/b
 EW&(j})^:(1=+/b) c j}~ ((0 3 6 9{BOXC)i.j{c){1 4 7 5{BOXC
)

root=: 4 : 0
 j=. k+<.-:1+(y i: 1)-k=. y i. 1
 (-j)|.(#y){.x,.,:' ',EW
)

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

Example use:

   (i.10) showtree _,}.p:inv i.10
                 ┌─ 6
     ┌─ 1 ─── 3 ─┴─ 7
                ┌─ 8
 0 ─┤     ┌─ 4 ─┴─ 9
     └─ 2 ─┴─ 5

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

   (i.10),: _,}.p:inv i.10
0 1 2 3 4 5 6 7 8 9
_ 0 0 1 2 2 3 3 4 4

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

   ((<'george') 0} (<'fred') 4} ":each i.10)showtree _,}.p:inv i.10
                         ┌─ 6
          ┌─ 1 ─── 3 ────┴─ 7
                        ┌─ 8
 george ─┤     ┌─ fred ─┴─ 9
          └─ 2 ─┴─ 5

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

JavaScript

HTML

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>

Plain text

Vertically centered tree

Translation of: Python
(Functional version)
(() => {
    'use strict';

    // UTF8 character-drawn tree, with options for compacting vs
    // centering parents, and for pruning out nodeless lines.

    const example = `
               ┌ Epsilon
       ┌─ Beta ┼─── Zeta
       │       └──── Eta
 Alpha ┼ Gamma ─── Theta
       │       ┌─── Iota
       └ Delta ┼── Kappa
               └─ Lambda`

    // drawTree2 :: Bool -> Bool -> Tree String -> String
    const drawTree2 = blnCompact => blnPruned => tree => {
        // Tree design and algorithm inspired by the Haskell snippet at:
        // https://doisinkidney.com/snippets/drawing-trees.html
        const
            // Lefts, Middle, Rights
            lmrFromStrings = xs => {
                const [ls, rs] = Array.from(splitAt(
                    Math.floor(xs.length / 2),
                    xs
                ));
                return Tuple3(ls, rs[0], rs.slice(1));
            },
            stringsFromLMR = lmr =>
            Array.from(lmr).reduce((a, x) => a.concat(x), []),
            fghOverLMR = (f, g, h) => lmr => {
                const [ls, m, rs] = Array.from(lmr);
                return Tuple3(ls.map(f), g(m), rs.map(h));
            };

        const lmrBuild = (f, w) => wsTree => {
            const
                leftPad = n => s => ' '.repeat(n) + s,
                xs = wsTree.nest,
                lng = xs.length,
                [nChars, x] = Array.from(wsTree.root);

            // LEAF NODE --------------------------------------
            return 0 === lng ? (
                Tuple3([], '─'.repeat(w - nChars) + x, [])

                // NODE WITH SINGLE CHILD -------------------------
            ) : 1 === lng ? (() => {
                const indented = leftPad(1 + w);
                return fghOverLMR(
                    indented,
                    z => '─'.repeat(w - nChars) + x + '─' + z,
                    indented
                )(f(xs[0]));

                // NODE WITH CHILDREN -----------------------------
            })() : (() => {
                const
                    cFix = x => xs => x + xs,
                    treeFix = (l, m, r) => compose(
                        stringsFromLMR,
                        fghOverLMR(cFix(l), cFix(m), cFix(r))
                    ),
                    _x = '─'.repeat(w - nChars) + x,
                    indented = leftPad(w),
                    lmrs = xs.map(f);
                return fghOverLMR(
                    indented,
                    s => _x + ({
                        '┌': '┬',
                        '├': '┼',
                        '│': '┤',
                        '└': '┴'
                    })[s[0]] + s.slice(1),
                    indented
                )(lmrFromStrings(
                    intercalate(
                        blnCompact ? [] : ['│'],
                        [treeFix(' ', '┌', '│')(lmrs[0])]
                        .concat(init(lmrs.slice(1)).map(
                            treeFix('│', '├', '│')
                        ))
                        .concat([treeFix('│', '└', ' ')(
                            lmrs[lmrs.length - 1]
                        )])
                    )
                ));
            })();
        };
        const
            measuredTree = fmapTree(
                v => {
                    const s = ' ' + v + ' ';
                    return Tuple(s.length, s)
                }, tree
            ),
            levelWidths = init(levels(measuredTree))
            .reduce(
                (a, level) => a.concat(maximum(level.map(fst))),
                []
            ),
            treeLines = stringsFromLMR(
                levelWidths.reduceRight(
                    lmrBuild, x => x
                )(measuredTree)
            );
        return unlines(
            blnPruned ? (
                treeLines.filter(
                    s => s.split('')
                    .some(c => !' │'.includes(c))
                )
            ) : treeLines
        );
    };

    // TESTS ----------------------------------------------
    const main = () => {

        // tree :: Tree String
        const tree = Node(
            'Alpha', [
                Node('Beta', [
                    Node('Epsilon', []),
                    Node('Zeta', []),
                    Node('Eta', [])
                ]),
                Node('Gamma', [Node('Theta', [])]),
                Node('Delta', [
                    Node('Iota', []),
                    Node('Kappa', []),
                    Node('Lambda', [])
                ])
            ]);

        // tree2 :: Tree Int
        const tree2 = Node(
            1,
            [
                Node(2, [
                    Node(4, []),
                    Node(5, [Node(7, [])])
                ]),
                Node(3, [
                    Node(6, [
                        Node(8, []),
                        Node(9, [])
                    ])
                ])
            ]
        );

        // strTrees :: String
        const strTrees = ([
            'Compacted (parents not all vertically centered):',
            drawTree2(true)(false)(tree2),
            'Fully expanded, with vertical centering:',
            drawTree2(false)(false)(tree),
            'Vertically centered, with nodeless lines pruned out:',
            drawTree2(false)(true)(tree),
        ].join('\n\n'));

        return (
            console.log(strTrees),
            strTrees
        );
    };

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

    // Node :: a -> [Tree a] -> Tree a
    const Node = (v, xs) => ({
        type: 'Node',
        root: v, // any type of value (consistent across tree)
        nest: xs || []
    });

    // Tuple (,) :: a -> b -> (a, b)
    const Tuple = (a, b) => ({
        type: 'Tuple',
        '0': a,
        '1': b,
        length: 2
    });

    // Tuple3 (,,) :: a -> b -> c -> (a, b, c)
    const Tuple3 = (a, b, c) => ({
        type: 'Tuple3',
        '0': a,
        '1': b,
        '2': c,
        length: 3
    });

    // compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
    const compose = (f, g) => x => f(g(x));

    // concat :: [[a]] -> [a]
    // concat :: [String] -> String
    const concat = xs =>
        0 < xs.length ? (() => {
            const unit = 'string' !== typeof xs[0] ? (
                []
            ) : '';
            return unit.concat.apply(unit, xs);
        })() : [];

    // fmapTree :: (a -> b) -> Tree a -> Tree b
    const fmapTree = (f, tree) => {
        const go = node => Node(
            f(node.root),
            node.nest.map(go)
        );
        return go(tree);
    };

    // fst :: (a, b) -> a
    const fst = tpl => tpl[0];

    // identity :: a -> a
    const identity = x => x;

    // init :: [a] -> [a]
    const init = xs =>
        0 < xs.length ? (
            xs.slice(0, -1)
        ) : undefined;

    // intercalate :: [a] -> [[a]] -> [a]
    // intercalate :: String -> [String] -> String
    const intercalate = (sep, xs) =>
        0 < xs.length && 'string' === typeof sep &&
        'string' === typeof xs[0] ? (
            xs.join(sep)
        ) : concat(intersperse(sep, xs));

    // intersperse(0, [1,2,3]) -> [1, 0, 2, 0, 3]

    // intersperse :: a -> [a] -> [a]
    // intersperse :: Char -> String -> String
    const intersperse = (sep, xs) => {
        const bln = 'string' === typeof xs;
        return xs.length > 1 ? (
            (bln ? concat : x => x)(
                (bln ? (
                    xs.split('')
                ) : xs)
                .slice(1)
                .reduce((a, x) => a.concat([sep, x]), [xs[0]])
            )) : xs;
    };

    // iterateUntil :: (a -> Bool) -> (a -> a) -> a -> [a]
    const iterateUntil = (p, f, x) => {
        const vs = [x];
        let h = x;
        while (!p(h))(h = f(h), vs.push(h));
        return vs;
    };

    // Returns Infinity over objects without finite length.
    // This enables zip and zipWith to choose the shorter
    // argument when one is non-finite, like cycle, repeat etc

    // length :: [a] -> Int
    const length = xs =>
        (Array.isArray(xs) || 'string' === typeof xs) ? (
            xs.length
        ) : Infinity;

    // levels :: Tree a -> [[a]]
    const levels = tree =>
        iterateUntil(
            xs => 1 > xs.length,
            ys => [].concat(...ys.map(nest)),
            [tree]
        ).map(xs => xs.map(root));

    // maximum :: Ord a => [a] -> a
    const maximum = xs =>
        0 < xs.length ? (
            xs.slice(1).reduce((a, x) => x > a ? x : a, xs[0])
        ) : undefined;

    // nest :: Tree a -> [a]
    const nest = tree => tree.nest;

    // root :: Tree a -> a
    const root = tree => tree.root;

    // splitAt :: Int -> [a] -> ([a], [a])
    const splitAt = (n, xs) =>
        Tuple(xs.slice(0, n), xs.slice(n));

    // unlines :: [String] -> String
    const unlines = xs => xs.join('\n');

    // MAIN ---
    return main();
})();
Output:
Compacted (parents not all vertically centered):

       ┌ 4 
   ┌ 2 ┴ 5 ─ 7 
 1 ┤       ┌ 8 
   └ 3 ─ 6 ┴ 9 

Fully expanded, with vertical centering:

               ┌ Epsilon 
               │
       ┌─ Beta ┼─── Zeta 
       │       │
       │       └──── Eta 
       │
 Alpha ┼ Gamma ─── Theta 
       │
       │       ┌─── Iota 
       │       │
       └ Delta ┼── Kappa 
               │
               └─ Lambda 

Vertically centered, with nodeless lines pruned out:

               ┌ Epsilon 
       ┌─ Beta ┼─── Zeta 
       │       └──── Eta 
 Alpha ┼ Gamma ─── Theta 
       │       ┌─── Iota 
       └ Delta ┼── Kappa 
               └─ Lambda

Decorated outline

(() => {
    'use strict';

    // drawTree :: Bool -> Tree String -> String
    const drawTree = blnCompact => tree => {
        // Simple decorated-outline style of ascii tree drawing,
        // with nodeless lines pruned out if blnCompact is True.
        const xs = draw(tree);
        return unlines(
            blnCompact ? (
                xs.filter(
                    s => s.split('')
                    .some(c => !' │'.includes(c))
                )
            ) : xs
        );
    };

    // draw :: Tree String -> [String]
    const draw = node => {
        // shift :: String -> String -> [String] -> [String]
        const shift = (first, other, xs) =>
            zipWith(
                append,
                cons(first, replicate(xs.length - 1, other)),
                xs
            );
        // drawSubTrees :: [Tree String] -> [String]
        const drawSubTrees = xs => {
            const lng = xs.length;
            return 0 < lng ? (
                1 < lng ? append(
                    cons(
                        '│',
                        shift('├─ ', '│  ', draw(xs[0]))
                    ),
                    drawSubTrees(xs.slice(1))
                ) : cons('│', shift('└─ ', '   ', draw(xs[0])))
            ) : [];
        };
        return append(
            lines(node.root.toString()),
            drawSubTrees(node.nest)
        );
    };

    // TEST -----------------------------------------------
    const main = () => {
        const tree = Node(
            'Alpha', [
                Node('Beta', [
                    Node('Epsilon', []),
                    Node('Zeta', []),
                    Node('Eta', [])
                ]),
                Node('Gamma', [Node('Theta', [])]),
                Node('Delta', [
                    Node('Iota', []),
                    Node('Kappa', []),
                    Node('Lambda', [])
                ])
            ]);

        return [true, false]
        .map(blnCompact => drawTree(blnCompact)(tree))
        .join('\n\n');
    };

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

    // Node :: a -> [Tree a] -> Tree a
    const Node = (v, xs) => ({
        type: 'Node',
        root: v, // any type of value (consistent across tree)
        nest: xs || []
    });

    // append (++) :: [a] -> [a] -> [a]
    // append (++) :: String -> String -> String
    const append = (xs, ys) => xs.concat(ys);

    // chars :: String -> [Char]
    const chars = s => s.split('');

    // cons :: a -> [a] -> [a]
    const cons = (x, xs) => [x].concat(xs);

    // Returns Infinity over objects without finite length.
    // This enables zip and zipWith to choose the shorter
    // argument when one is non-finite, like cycle, repeat etc

    // length :: [a] -> Int
    const length = xs =>
        (Array.isArray(xs) || 'string' === typeof xs) ? (
            xs.length
        ) : Infinity;

    // lines :: String -> [String]
    const lines = s => s.split(/[\r\n]/);

    // replicate :: Int -> a -> [a]
    const replicate = (n, x) =>
        Array.from({
            length: n
        }, () => x);

    // take :: Int -> [a] -> [a]
    const take = (n, xs) =>
        xs.slice(0, n);

    // unlines :: [String] -> String
    const unlines = xs => xs.join('\n');

    // Use of `take` and `length` here allows zipping with non-finite lists
    // i.e. generators like cycle, repeat, iterate.

    // zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
    const zipWith = (f, xs, ys) => {
        const
            lng = Math.min(length(xs), length(ys)),
            as = take(lng, xs),
            bs = take(lng, ys);
        return Array.from({
            length: lng
        }, (_, i) => f(as[i], bs[i], i));
    };

    // MAIN ---
    return main();
})();
Output:
Alpha
├─ Beta
│  ├─ Epsilon
│  ├─ Zeta
│  └─ Eta
├─ Gamma
│  └─ Theta
└─ Delta
   ├─ Iota
   ├─ Kappa
   └─ Lambda

Alpha
│
├─ Beta
│  │
│  ├─ Epsilon
│  │
│  ├─ Zeta
│  │
│  └─ Eta
│
├─ Gamma
│  │
│  └─ Theta
│
└─ Delta
   │
   ├─ Iota
   │
   ├─ Kappa
   │
   └─ Lambda

jq

Works with: jq

Works with gojq, the Go implementation of jq

In this entry, a tree $t is represented by an array [root, child1, child2 ...] where root must be present and cannot be an array, and the children, which may also be trees, may all be absent.

The tree [0, 1, 2, 3] is displayed as:

0
├─ 1
├─ 2
└─ 3
# Input: an array representing a tree
# Output: a stream of strings representing the tree
# In this implementation, empty arrays in the tree are simply ignored.
def printTree:

  def tidy:
    sub("└─$"; "  ")
    | sub("├─$"; "| ") ; 

  # Input: a string prefix
  def print($tree):
    if $tree|type != "array" then . + ($tree|tostring)
    else # ignore empty arrays
    ($tree | map(select(if type == "array" then length>0 else true end))) as $tree 
    | if $tree|length == 0 then empty
      elif $tree|length == 1
      then print($tree[0])
      else print($tree[0]),
           ($tree[1:] as $children
            | tidy as $p
             | ($p + ( "├─" | print($children[:-1][]))),
               ($p + ( "└─" | print($children[-1]))) )
      end
    end ;

  . as $tree
  | "" | print($tree) ;

Examples

def bigTree:
  ["a",
   ["aa",
    ["aaa",
     ["aaaa"],
     ["aaab",
      ["aaaba"],
      ["aaabb"]],
     ["aaac"]]],
   ["ab"],
   ["ac",
    ["aca"],
    ["acb"],
    ["acc"]]] ;

[0, 1, 2, 3],
[1,[2,3,[4, 5, [6,7,8], 9, [10,11]]]],
bigTree
| ("Tree with array representation:\n\(.)\n",
  printTree,
  "")
Output:
Tree with array representation:
[0,1,2,3]

0
├─1
├─2
└─3

Tree with array representation:
[1,[2,3,[4,5,[6,7,8],9,[10,11]]]]

1
└─2
  ├─3
  └─4
    ├─5
    ├─6
    | ├─7
    | └─8
    ├─9
    └─10
      └─11

Tree with array representation:
["a",["aa",["aaa",["aaaa"],["aaab",["aaaba"],["aaabb"]],["aaac"]]],["ab"],["ac",["aca"],["acb"],["acc"]]]

a
├─aa
| └─aaa
|   ├─aaaa
|   ├─aaab
|   | ├─aaaba
|   | └─aaabb
|   └─aaac
├─ab
└─ac
  ├─aca
  ├─acb
  └─acc

Julia

Run from Julia REPL.

using Gadfly, LightGraphs, GraphPlot

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

Kotlin

Translation of: C
// version 1.2.0

import java.util.Random

class Stem(var str: String? = null, var next: Stem? = null)

const val SDOWN = "  |"
const val SLAST = "  `"
const val SNONE = "   "

val rand = Random()

fun tree(root: Int, head: Stem?) {
    val col = Stem()
    var head2 = head
    var tail = head
    while (tail != null) {
        print(tail.str)
        if (tail.next == null) break
        tail = tail.next
    }
    println("--$root")
    if (root <= 1) return
    if (tail != null && tail.str == SLAST) tail.str = SNONE
    if (tail == null) {
        head2 = col
        tail = head2
    }
    else {
        tail.next = col
    }
    var root2 = root
    while (root2 != 0) { // make a tree by doing something random
        val r = 1 + rand.nextInt(root2)
        root2 -= r
        col.str = if (root2 != 0) SDOWN else SLAST
        tree(r, head2)
    }
    tail.next = null
}

fun main(args: Array<String>) {
    val n = 8
    tree(n, null)
}

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

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

Lingo

-- parent script "TreeItem"
-- (minimal implementation with direct property access)

property name
property children

on new (me, itemName)
  me.name = itemName
  me.children = []
  return me
end

on addChild (me, child)
  me.children.add(child)
end

-- print a tree
on printTree (me, treeItem, indent)
  if voidP(treeItem) then treeItem = me
  if voidP(indent) then indent = ""
  put indent&treeItem.name
  repeat with c in treeItem.children
    me.printTree(c, indent&"  ")
  end repeat
end

Usage:

-- create a tree
root = script("TreeItem").new("root")
a = script("TreeItem").new("a")
root.addChild(a)
b = script("TreeItem").new("b")
root.addChild(b)
a1 = script("TreeItem").new("a1")
a.addChild(a1)
a11 = script("TreeItem").new("a11")
a1.addChild(a11)
a12 = script("TreeItem").new("a12")
a1.addChild(a12)
b1 = script("TreeItem").new("b1")
b.addChild(b1)

-- print the tree
root.printTree()
Output:
-- "root"
-- "  a"
-- "    a1"
-- "      a11"
-- "      a12"
-- "  b"
-- "    b1"

Lua

Translation of: C#
function makeTree(v,ac)
    if type(ac) == "table" then
        return {value=v,children=ac}
    else
        return {value=v}
    end
end

function printTree(t,last,prefix)
    if last == nil then
        printTree(t, false, '')
    else
        local current = ''
        local next = ''

        if last then
            current = prefix .. '\\-' .. t.value
            next = prefix .. '  '
        else
            current = prefix .. '|-' .. t.value
            next = prefix .. '| '
        end

        print(current:sub(3))
        if t.children ~= nil then
            for k,v in pairs(t.children) do
                printTree(v, k == #t.children, next)
            end
        end
    end
end

printTree(
    makeTree('A', {
        makeTree('B0', {
            makeTree('C1'),
            makeTree('C2', {
                makeTree('D', {
                    makeTree('E1'),
                    makeTree('E2'),
                    makeTree('E3')
                })
            }),
            makeTree('C3', {
                makeTree('F1'),
                makeTree('F2'),
                makeTree('F3', {makeTree('G')}),
                makeTree('F4', {
                    makeTree('H1'),
                    makeTree('H2')
                })
            })
        }),
        makeTree('B1',{
            makeTree('K1'),
            makeTree('K2', {
                makeTree('L1', {makeTree('M')}),
                makeTree('L2'),
                makeTree('L3')
            }),
            makeTree('K3')
        })
    })
)
Output:
A
|-B0
| |-C1
| |-C2
| | \-D
| |   |-E1
| |   |-E2
| |   \-E3
| \-C3
|   |-F1
|   |-F2
|   |-F3
|   | \-G
|   \-F4
|     |-H1
|     \-H2
\-B1
  |-K1
  |-K2
  | |-L1
  | | \-M
  | |-L2
  | \-L3
  \-K3

Maple

T := GraphTheory:-Graph([1, 2, 3, 4, 5], {{1, 2}, {2, 3}, {2, 4}, {4, 5}}):
GraphTheory:-DrawGraph(T, style = tree);

Mathematica/Wolfram Language

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

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

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]

File:Opener.jpg

Maxima

load(graphs)$

g: random_tree(10)$

is_tree(g);
true

draw_graph(g)$

Nim

Translation of: Haskell
import strutils

type
  Node[T] = ref 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")
Output:
--1
  |--2
  |  |--4
  |  |  |--7
  |  |  |  |-- (null)
  |  |  |  `-- (null)
  |  |  `-- (null)
  |  `--5
  |     |-- (null)
  |     `-- (null)
  `--3
     |--6
     |  |--8
     |  |  |-- (null)
     |  |  `-- (null)
     |  `--9
     |     |-- (null)
     |     `-- (null)
     `-- (null)

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

Phix

--
-- demo\rosetta\VisualiseTree.exw
--
with javascript_semantics
                        
-- To the theme tune of the Milk Tray Ad iyrt,
-- All because the Windows console hates utf8:
constant TL = '\#DA', -- aka '┌'
         VT = '\#B3', -- aka '│'
         BL = '\#C0', -- aka '└'
         HZ = '\#C4', -- aka '─'
         HS = "\#C4"  -- (string version of HZ)

function w1252_to_utf8(string s)
    if platform()!=WINDOWS then
        s = substitute_all(s,{ TL, VT, BL, HZ},
                             {"┌","│","└","─"})
    end if
    return s
end function
--</hates utf8>

procedure visualise_tree(object tree, string root=HS)
    if atom(tree) then
        puts(1,"<empty>\n")
    else
        object {v,l,r} = tree
        integer g = root[$]
        if sequence(l) then
            root[$] = iff(g=TL or g=HZ?' ':VT)
            visualise_tree(l,root&TL)
        end if
        root[$] = g
        printf(1,"%s%d\n",{w1252_to_utf8(root),v})
        if sequence(r) then
            root[$] = iff(g=TL?VT:' ')
            visualise_tree(r,root&BL)
        end if
    end if
end procedure

function rand_tree(integer low, integer high)
    for i=1 to 2 do
        integer v = rand(high-low+1)-1+low
        if v!=low
        and v!=high then
            return {v,rand_tree(low,v),rand_tree(v,high)}
        end if
    end for
    return 0
end function

object tree = rand_tree(0,20)   -- (can be 0, <1% chance)

visualise_tree(tree)
--pp(tree,{pp_Nest,10})
{} = wait_key()
Output:
   ┌3
   │└4
   │ └5
  ┌7
 ┌9
 │└10
 │ └11
─12
 │ ┌13
 │┌14
 └15
  │ ┌16
  │┌17
  ││└18
  └19

A much simpler but less aesthetically pleasing way is just

pp(tree,{pp_Nest,10})
Output:
{1,
 0,
 {5,
  0,
  {9,
   {8,
    {6,
     0,
     0},
    0},
   0}}}

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

Prolog

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

Python

Library module

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


Functional composition

Vertically centered parents

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

Works with: Python version 3
'''Textually visualized tree, with vertically-centered parent nodes'''

from functools import reduce
from itertools import (chain, takewhile)

'''
               ┌ Epsilon
               ├─── Zeta
       ┌─ Beta ┼──── Eta
       │       │         ┌───── Mu
       │       └── Theta ┤
 Alpha ┤                 └───── Nu
       ├ Gamma ────── Xi ─ Omicron
       │       ┌─── Iota
       └ Delta ┼── Kappa
               └─ Lambda
'''
# Tree style and algorithm inspired by the Haskell snippet at:
# https://doisinkidney.com/snippets/drawing-trees.html


# drawTree2 :: Bool -> Bool -> Tree a -> String
def drawTree2(blnCompact):
    '''Monospaced UTF8 left-to-right text tree in a
       compact or expanded format, with any lines
       containing no nodes optionally pruned out.
    '''
    def go(blnPruned, tree):
        # measured :: a -> (Int, String)
        def measured(x):
            '''Value of a tree node
               tupled with string length.
            '''
            s = ' ' + str(x) + ' '
            return len(s), s

        # lmrFromStrings :: [String] -> ([String], String, [String])
        def lmrFromStrings(xs):
            '''Lefts, Mid, Rights.'''
            i = len(xs) // 2
            ls, rs = xs[0:i], xs[i:]
            return ls, rs[0], rs[1:]

        # stringsFromLMR :: ([String], String, [String]) -> [String]
        def stringsFromLMR(lmr):
            ls, m, rs = lmr
            return ls + [m] + rs

        # fghOverLMR
        # :: (String -> String)
        # -> (String -> String)
        # -> (String -> String)
        # -> ([String], String, [String])
        # -> ([String], String, [String])
        def fghOverLMR(f, g, h):
            def go(lmr):
                ls, m, rs = lmr
                return (
                    [f(x) for x in ls],
                    g(m),
                    [h(x) for x in rs]
                )
            return lambda lmr: go(lmr)

        # leftPad :: Int -> String -> String
        def leftPad(n):
            return lambda s: (' ' * n) + s

        # treeFix :: (Char, Char, Char) -> ([String], String, [String])
        #                               ->  [String]
        def treeFix(l, m, r):
            def cfix(x):
                return lambda xs: x + xs
            return compose(stringsFromLMR)(
                fghOverLMR(cfix(l), cfix(m), cfix(r))
            )

        def lmrBuild(w, f):
            def go(wsTree):
                nChars, x = wsTree['root']
                _x = ('─' * (w - nChars)) + x
                xs = wsTree['nest']
                lng = len(xs)

                # linked :: String -> String
                def linked(s):
                    c = s[0]
                    t = s[1:]
                    return _x + '┬' + t if '┌' == c else (
                        _x + '┤' + t if '│' == c else (
                            _x + '┼' + t if '├' == c else (
                                _x + '┴' + t
                            )
                        )
                    )

                # LEAF ------------------------------------
                if 0 == lng:
                    return ([], _x, [])

                # SINGLE CHILD ----------------------------
                elif 1 == lng:
                    def lineLinked(z):
                        return _x + '─' + z
                    rightAligned = leftPad(1 + w)
                    return fghOverLMR(
                        rightAligned,
                        lineLinked,
                        rightAligned
                    )(f(xs[0]))

                # CHILDREN --------------------------------
                else:
                    rightAligned = leftPad(w)
                    lmrs = [f(x) for x in xs]
                    return fghOverLMR(
                        rightAligned,
                        linked,
                        rightAligned
                    )(
                        lmrFromStrings(
                            intercalate([] if blnCompact else ['│'])(
                                [treeFix(' ', '┌', '│')(lmrs[0])] + [
                                    treeFix('│', '├', '│')(x) for x
                                    in lmrs[1:-1]
                                ] + [treeFix('│', '└', ' ')(lmrs[-1])]
                            )
                        )
                    )
            return lambda wsTree: go(wsTree)

        measuredTree = fmapTree(measured)(tree)
        levelWidths = reduce(
            lambda a, xs: a + [max(x[0] for x in xs)],
            levels(measuredTree),
            []
        )
        treeLines = stringsFromLMR(
            foldr(lmrBuild)(None)(levelWidths)(
                measuredTree
            )
        )
        return [
            s for s in treeLines
            if any(c not in '│ ' for c in s)
        ] if (not blnCompact and blnPruned) else treeLines

    return lambda blnPruned: (
        lambda tree: '\n'.join(go(blnPruned, tree))
    )


# TEST ----------------------------------------------------
# main :: IO ()
def main():
    '''Trees drawn in varying formats'''

    # tree1 :: Tree Int
    tree1 = Node(1)([
        Node(2)([
            Node(4)([
                Node(7)([])
            ]),
            Node(5)([])
        ]),
        Node(3)([
            Node(6)([
                Node(8)([]),
                Node(9)([])
            ])
        ])
    ])

    # tree :: Tree String
    tree2 = Node('Alpha')([
        Node('Beta')([
            Node('Epsilon')([]),
            Node('Zeta')([]),
            Node('Eta')([]),
            Node('Theta')([
                Node('Mu')([]),
                Node('Nu')([])
            ])
        ]),
        Node('Gamma')([
            Node('Xi')([Node('Omicron')([])])
        ]),
        Node('Delta')([
            Node('Iota')([]),
            Node('Kappa')([]),
            Node('Lambda')([])
        ])
    ])

    print(
        '\n\n'.join([
            'Fully compacted (parents not all centered):',
            drawTree2(True)(False)(
                tree1
            ),
            'Expanded with vertically centered parents:',
            drawTree2(False)(False)(
                tree2
            ),
            'Centered parents with nodeless lines pruned out:',
            drawTree2(False)(True)(
                tree2
            )
        ])
    )


# GENERIC -------------------------------------------------

# Node :: a -> [Tree a] -> Tree a
def Node(v):
    '''Contructor for a Tree node which connects a
       value of some kind to a list of zero or
       more child trees.
    '''
    return lambda xs: {'type': 'Tree', 'root': v, 'nest': xs}


# compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
def compose(g):
    '''Right to left function composition.'''
    return lambda f: lambda x: g(f(x))


# concatMap :: (a -> [b]) -> [a] -> [b]
def concatMap(f):
    '''A concatenated list over which a function has been mapped.
       The list monad can be derived by using a function f which
       wraps its output in a list,
       (using an empty list to represent computational failure).
    '''
    return lambda xs: list(
        chain.from_iterable(map(f, xs))
    )


# fmapTree :: (a -> b) -> Tree a -> Tree b
def fmapTree(f):
    '''A new tree holding the results of
       applying f to each root in
       the existing tree.
    '''
    def go(x):
        return Node(f(x['root']))(
            [go(v) for v in x['nest']]
        )
    return lambda tree: go(tree)


# foldr :: (a -> b -> b) -> b -> [a] -> b
def foldr(f):
    '''Right to left reduction of a list,
       using the binary operator f, and
       starting with an initial accumulator value.
    '''
    def g(x, a):
        return f(a, x)
    return lambda acc: lambda xs: reduce(
        g, xs[::-1], acc
    )


# intercalate :: [a] -> [[a]] -> [a]
# intercalate :: String -> [String] -> String
def intercalate(x):
    '''The concatenation of xs
       interspersed with copies of x.
    '''
    return lambda xs: x.join(xs) if isinstance(x, str) else list(
        chain.from_iterable(
            reduce(lambda a, v: a + [x, v], xs[1:], [xs[0]])
        )
    ) if xs else []


# iterate :: (a -> a) -> a -> Gen [a]
def iterate(f):
    '''An infinite list of repeated
       applications of f to x.
    '''
    def go(x):
        v = x
        while True:
            yield v
            v = f(v)
    return lambda x: go(x)


# levels :: Tree a -> [[a]]
def levels(tree):
    '''A list of the nodes at each level of the tree.'''
    return list(
        map_(map_(root))(
            takewhile(
                bool,
                iterate(concatMap(nest))(
                    [tree]
                )
            )
        )
    )


# map :: (a -> b) -> [a] -> [b]
def map_(f):
    '''The list obtained by applying f
       to each element of xs.
    '''
    return lambda xs: list(map(f, xs))


# nest :: Tree a -> [Tree a]
def nest(t):
    '''Accessor function for children of tree node.'''
    return t['nest'] if 'nest' in t else None


# root :: Tree a -> a
def root(t):
    '''Accessor function for data of tree node.'''
    return t['root'] if 'root' in t else None


# MAIN ---
if __name__ == '__main__':
    main()
Output:
Fully compacted (parents not all centered):

       ┌ 4 ─ 7 
   ┌ 2 ┴ 5 
 1 ┤       ┌ 8 
   └ 3 ─ 6 ┴ 9 

Expanded with vertically centered parents:

               ┌ Epsilon 
               │
               ├─── Zeta 
               │
       ┌─ Beta ┼──── Eta 
       │       │
       │       │         ┌───── Mu 
       │       └── Theta ┤
 Alpha ┤                 └───── Nu 
       │
       ├ Gamma ────── Xi ─ Omicron 
       │
       │       ┌─── Iota 
       │       │
       └ Delta ┼── Kappa 
               │
               └─ Lambda 

Centered parents with nodeless lines pruned out:

               ┌ Epsilon 
               ├─── Zeta 
       ┌─ Beta ┼──── Eta 
       │       │         ┌───── Mu 
       │       └── Theta ┤
 Alpha ┤                 └───── Nu 
       ├ Gamma ────── Xi ─ Omicron 
       │       ┌─── Iota 
       └ Delta ┼── Kappa 
               └─ Lambda 

Simple decorated-outline tree

Works with: Python version 3
'''Visualize a tree'''

from itertools import (chain, repeat, starmap)
from operator import (add)


# drawTree :: Tree a -> String
def drawTree(tree):
    '''ASCII diagram of a tree.'''
    return '\n'.join(draw(tree))


# draw :: Tree a -> [String]
def draw(node):
    '''List of the lines of an ASCII
       diagram of a tree.'''
    def shift(first, other, xs):
        return list(starmap(
            add,
            zip(
                chain([first], repeat(other, len(xs) - 1)),
                xs
            )
        ))

    def drawSubTrees(xs):
        return (
            (
                ['│'] + shift(
                    '├─ ', '│  ', draw(xs[0])
                ) + drawSubTrees(xs[1:])
            ) if 1 < len(xs) else ['│'] + shift(
                '└─ ', '   ', draw(xs[0])
            )
        ) if xs else []

    return (str(root(node))).splitlines() + (
        drawSubTrees(nest(node))
    )


# TEST ----------------------------------------------------
# main :: IO ()
def main():
    '''Test'''

    # tree :: Tree Int
    tree = Node(1)([
        Node(2)([
            Node(4)([
                Node(7)([])
            ]),
            Node(5)([])
        ]),
        Node(3)([
            Node(6)([
                Node(8)([]),
                Node(9)([])
            ])
        ])
    ])

    print(drawTree(tree))


# GENERIC -------------------------------------------------


# Node :: a -> [Tree a] -> Tree a
def Node(v):
    '''Contructor for a Tree node which connects a
       value of some kind to a list of zero or
       more child trees.'''
    return lambda xs: {'root': v, 'nest': xs}


# nest :: Tree a -> [Tree a]
def nest(tree):
    '''Accessor function for children of tree node.'''
    return tree['nest'] if 'nest' in tree else None


# root :: Dict -> a
def root(dct):
    '''Accessor function for data of tree node.'''
    return dct['root'] if 'root' in dct else None


# MAIN ---
if __name__ == '__main__':
    main()
Output:
1
│
├─ 2
│  │
│  ├─ 4
│  │  │
│  │  └─ 7
│  │
│  └─ 5
│
└─ 3
   │
   └─ 6
      │
      ├─ 8
      │
      └─ 9

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

Raku

(formerly 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=>[]]];

.map({.join("\n")}).join("\n").say for visualize-tree($tree, *.key, *.value.list);
Output:
root
├─a
│ └─a1
│   └─a11
└─b
  ├─b1
  │ └─b11
  ├─b2
  └─b3

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=changestr('` ',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

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>
def ptree(tree,indent="  ")
  case tree
  when Array
    head,*tail=tree
    ptree(head,indent)
    s=tail.size-1
    tail.each_with_index { |tree1,i| ptree(tree1,"#{indent}#{((i==s) ? ' ':'|')}  ") } 
  else
     puts(indent.gsub(/\s\s$/,"--").gsub(/ --$/,"\\--")+tree.to_s)
  end
end
ptree [1,2,3,[4,5,6,[7,8,9]],3,[22,33]]

will produce:

Output:
--1
  |--2
  |--3
  |--4
  |  |--5
  |  |--6
  |  \--7
  |     |--8
  |     \--9
  |--3
  \--22
     \--33

Rust

Console visualization of binary trees translated from parts of the C AVL tree solution.

extern crate rustc_serialize;
extern crate term_painter;

use rustc_serialize::json;
use std::fmt::{Debug, Display, Formatter, Result};
use term_painter::ToStyle;
use term_painter::Color::*;

type NodePtr = Option<usize>;

#[derive(Debug, PartialEq, Clone, Copy)]
enum Side {
    Left,
    Right,
    Up,
}

#[derive(Debug, PartialEq, Clone, Copy)]
enum DisplayElement {
    TrunkSpace,
    SpaceLeft,
    SpaceRight,
    SpaceSpace,
    Root,
}

impl DisplayElement {
    fn string(&self) -> String {
        match *self {
            DisplayElement::TrunkSpace => "    │   ".to_string(),
            DisplayElement::SpaceRight => "    ┌───".to_string(),
            DisplayElement::SpaceLeft => "    └───".to_string(),
            DisplayElement::SpaceSpace => "        ".to_string(),
            DisplayElement::Root => "├──".to_string(),
        }
    }
}

#[derive(Debug, Clone, Copy, RustcDecodable, RustcEncodable)]
struct Node<K, V> {
    key: K,
    value: V,
    left: NodePtr,
    right: NodePtr,
    up: NodePtr,
}

impl<K: Ord + Copy, V: Copy> Node<K, V> {
    pub fn get_ptr(&self, side: Side) -> NodePtr {
        match side {
            Side::Up => self.up,
            Side::Left => self.left,
            _ => self.right,
        }
    }
}

#[derive(Debug, RustcDecodable, RustcEncodable)]
struct Tree<K, V> {
    root: NodePtr,
    store: Vec<Node<K, V>>,
}

impl<K: Ord + Copy + Debug + Display, V: Debug + Copy + Display> Tree<K, V> {
    pub fn get_node(&self, np: NodePtr) -> Node<K, V> {
        assert!(np.is_some());
        self.store[np.unwrap()]
    }

    pub fn get_pointer(&self, np: NodePtr, side: Side) -> NodePtr {
        assert!(np.is_some());
        self.store[np.unwrap()].get_ptr(side)
    }

    // Prints the tree with root p.  The idea is to do an in-order traversal
    // (reverse in-order in this case, where right is on top), and print nodes as they
    // are visited, one per line. Each invocation of display() gets its own copy
    // of the display element vector e, which is grown with either whitespace or
    // a trunk element, then modified in its last and possibly second-to-last
    // characters in context.
    fn display(&self, p: NodePtr, side: Side, e: &Vec<DisplayElement>, f: &mut Formatter) {
        if p.is_none() {
            return;
        }

        let mut elems = e.clone();
        let node = self.get_node(p);
        let mut tail = DisplayElement::SpaceSpace;
        if node.up != self.root {
            // If the direction is switching, I need the trunk element to appear in the lines
            // printed before that node is visited.
            if side == Side::Left && node.right.is_some() {
                elems.push(DisplayElement::TrunkSpace);
            } else {
                elems.push(DisplayElement::SpaceSpace);
            }
        }
        let hindex = elems.len() - 1;
        self.display(node.right, Side::Right, &elems, f);

        if p == self.root {
            elems[hindex] = DisplayElement::Root;
            tail = DisplayElement::TrunkSpace;
        } else if side == Side::Right {
            // Right subtree finished
            elems[hindex] = DisplayElement::SpaceRight;
            // Prepare trunk element in case there is a left subtree
            tail = DisplayElement::TrunkSpace;
        } else if side == Side::Left {
            elems[hindex] = DisplayElement::SpaceLeft;
            let parent = self.get_node(node.up);
            if parent.up.is_some() && self.get_pointer(parent.up, Side::Right) == node.up {
                // Direction switched, need trunk element starting with this node/line
                elems[hindex - 1] = DisplayElement::TrunkSpace;
            }
        }

        // Visit node => print accumulated elements. Each node gets a line and each line gets a
        // node.
        for e in elems.clone() {
            let _ = write!(f, "{}", e.string());
        }
        let _ = write!(f,
                       "{key:>width$} ",
                       key = Green.bold().paint(node.key),
                       width = 2);
        let _ = write!(f,
                       "{value:>width$}\n",
                       value = Blue.bold().paint(format!("{:.*}", 2, node.value)),
                       width = 4);

        // Overwrite last element before continuing traversal
        elems[hindex] = tail;

        self.display(node.left, Side::Left, &elems, f);
    }
}

impl<K: Ord + Copy + Debug + Display, V: Debug + Copy + Display> Display for Tree<K, V> {
    fn fmt(&self, f: &mut Formatter) -> Result {
        if self.root.is_none() {
            write!(f, "[empty]")
        } else {
            let mut v: Vec<DisplayElement> = Vec::new();
            self.display(self.root, Side::Up, &mut v, f);
            Ok(())
        }
    }
}

/// Decodes and prints a previously generated tree.
fn main() {
    let encoded = r#"{"root":0,"store":[{"key":0,"value":0.45,"left":1,"right":3,
        "up":null},{"key":-8,"value":-0.94,"left":7,"right":2,"up":0}, {"key":-1,
        "value":0.15,"left":8,"right":null,"up":1},{"key":7, "value":-0.29,"left":4,
        "right":9,"up":0},{"key":5,"value":0.80,"left":5,"right":null,"up":3},
        {"key":4,"value":-0.85,"left":6,"right":null,"up":4},{"key":3,"value":-0.46,
        "left":null,"right":null,"up":5},{"key":-10,"value":-0.85,"left":null,
        "right":13,"up":1},{"key":-6,"value":-0.42,"left":null,"right":10,"up":2},
        {"key":9,"value":0.63,"left":12,"right":null,"up":3},{"key":-3,"value":-0.83,
        "left":null,"right":11,"up":8},{"key":-2,"value":0.75,"left":null,"right":null,
        "up":10},{"key":8,"value":-0.48,"left":null,"right":null,"up":9},{"key":-9,
        "value":0.53,"left":null,"right":null,"up":7}]}"#;
    let tree: Tree<i32, f32> = json::decode(&encoded).unwrap();
    println!("{}", tree);
}
Output:

Sidef

Translation of: Raku
func visualize_tree(tree, label, children,
                    indent = '',
                    mids = ['├─', '│ '],
                    ends = ['└─', '  '],
) {
    func visit(node, pre) {
        gather {
            take(pre[0] + label(node))
            var chldn = children(node)
            var end = chldn.end
            chldn.each_kv { |i, child|
                if (i == end) { take(visit(child, [pre[1]] ~X+ ends)) }
                else          { take(visit(child, [pre[1]] ~X+ mids)) }
            }
        }
    }
    visit(tree, [indent] * 2)
}

var tree = 'root':['a':['a1':['a11':[]]],'b':['b1':['b11':[]],'b2':[],'b3':[]]]
say visualize_tree(tree, { .first }, { .second }).flatten.join("\n")
Output:
root
├─a
│ └─a1
│   └─a11
└─b
  ├─b1
  │ └─b11
  ├─b2
  └─b3

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

Wren

Translation of: C
Library: Wren-dynamic
import "./dynamic" for Struct
import "random" for Random

var Stem = Struct.create("Stem", ["str", "next"])

var SDOWN = "  |"
var SLAST = "  `"
var SNONE = "   "

var rand = Random.new()

var tree // recursive
tree = Fn.new { |root, head|
    var col = Stem.new(null, null)
    var tail = head
    while (tail) {
        System.write(tail.str)
        if (!tail.next) break
        tail = tail.next
    }
    System.print("--%(root)")
    if (root <= 1) return
    if (tail && tail.str == SLAST) tail.str = SNONE
    if (!tail) {
        tail = head = col
    } else {
        tail.next = col
    }
    while (root != 0) { // make a tree by doing something random
        var r = 1 + rand.int(root)
        root = root - r
        col.str = (root != 0) ? SDOWN : SLAST
        tree.call(r, head)
    }
    tail.next = null
}

var n = 8
tree.call(n, null)
Output:

Sample output:

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

Yabasic

clear screen

dim colore$(1)

maxCol = token("white yellow cyan green red", colore$())

showTree(0, "[1[2[3][4[5][6]][7]][8[9]]]")
print "\n\n\n"
showTree(0, "[1[2[3[4]]][5[6][7[8][9]]]]")
 
sub showTree(n, A$)
    local i, c$
    static co
    
    c$ = left$(A$, 1)
    
    if c$ = "" return
    
    switch c$
    case "[":   co = co + 1 : showTree(n + 1, right$(A$, len(A$) - 1))
                break
    case "]":   co = co - 1 : showTree(n - 1, right$(A$, len(A$) - 1))
                break
    default:    for i = 2 to n
                    print "  ";
                next i
                co = max(min(co, maxCol), 1)
                print color(colore$(co)) "\xc0-", c$
                showTree(n, right$(A$, len(A$) - 1))
                break
    end switch
end sub

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
}

PHP

<?php

function printTree( array $tree , string $key = "." , string $stack = "" , $first = TRUE , $firstPadding = NULL )
{
    if ( gettype($tree) == "array" )
    {
        if($firstPadding === NULL) $firstPadding = ( count($tree)>1 ) ? "│   " : "    " ;
        echo   $key . PHP_EOL ;
        foreach ($tree as $key => $value) {
            if ($key === array_key_last($tree)){
                echo (($first) ? "" : $firstPadding ) . $stack . "└── ";
                $padding = "    ";
                if($first) $firstPadding = "    ";
            }
            else {
                echo (($first) ? "" : $firstPadding ) . $stack . "├── ";
                $padding = "│   ";
            }
            if( is_array($value) )printTree( $value , $key ,   $stack . (($first) ? "" : $padding ) , FALSE , $firstPadding );
            else echo $key . " -> " . $value . PHP_EOL;
        }
    }
    else echo $tree . PHP_EOL;
}



// ---------------------------------------TESTING FUNCTION-------------------------------------


$sample_array_1 = 
[
    0 => [
        'item_id' => 6,
        'price' => "2311.00",
        'qty' => 12,
        'discount' => 0
    ],
    1 => [
        'item_id' => 7,
        'price' => "1231.00",
        'qty' => 1,
        'discount' => 12
    ],
    2 => [
        'item_id' => 8,
        'price' => "123896.00",
        'qty' => 0,
        'discount' => 24
    ]
];
$sample_array_2 = array(
    array(
         "name"=>"John",
        "lastname"=>"Doe",
        "country"=>"Japan",
        "nationality"=>"Japanese",
        "job"=>"web developer",
        "hobbies"=>array(
                "sports"=>"soccer",
                "others"=>array(
                        "freetime"=>"watching Tv"
                )
        )

    )
);
$sample_array_3 = [
    "root" => [
        "first_depth_node1" =>[
            "second_depth_node1",
            "second_depth_node2" => [
                "third_depth_node1" ,
                "third_depth_node2" ,
                "third_depth_node3" => [
                    "fourth_depth_node1",
                    "fourth_depth_node2",
                ]
                ],
            "second_depth_node3",
        ] ,
        "first_depth_node2" => [
            "second_depth_node4" => [ "third_depth_node3" => [1]]
        ]
        ]
];
$sample_array_4 = [];
$sample_array_5 = ["1"];
$sample_array_5 = ["1"];
$sample_array_6 = [
    "T",
    "Ta",
    "Tad",
    "Tada",
    "Tadav",
    "Tadavo",
    "Tadavom",
    "Tadavomn",
    "Tadavomni",
    "Tadavomnis",
    "TadavomnisT",
];


printTree($sample_array_1);
echo PHP_EOL . "------------------------------" . PHP_EOL;
printTree($sample_array_2);
echo PHP_EOL . "------------------------------" . PHP_EOL;
printTree($sample_array_3);
echo PHP_EOL . "------------------------------" . PHP_EOL;
printTree($sample_array_4);
echo PHP_EOL . "------------------------------" . PHP_EOL;
printTree($sample_array_5);
echo PHP_EOL . "------------------------------" . PHP_EOL;
printTree($sample_array_6);


?>
Output:
.
├── 0
│   ├── item_id -> 6
│   ├── price -> 2311.00
│   ├── qty -> 12
│   └── discount -> 0
├── 1
│   ├── item_id -> 7
│   ├── price -> 1231.00
│   ├── qty -> 1
│   └── discount -> 12
└── 2
    ├── item_id -> 8
    ├── price -> 123896.00
    ├── qty -> 0
    └── discount -> 24

------------------------------
.
└── 0
    ├── name -> John
    ├── lastname -> Doe
    ├── country -> Japan
    ├── nationality -> Japanese
    ├── job -> web developer
    └── hobbies
        ├── sports -> soccer
        └── others
            └── freetime -> watching Tv

------------------------------
.
└── root
    ├── first_depth_node1
    │   ├── 0 -> second_depth_node1
    │   ├── second_depth_node2
    │   │   ├── 0 -> third_depth_node1
    │   │   ├── 1 -> third_depth_node2
    │   │   └── third_depth_node3
    │   │       ├── 0 -> fourth_depth_node1
    │   │       └── 1 -> fourth_depth_node2
    │   └── 1 -> second_depth_node3
    └── first_depth_node2
        └── second_depth_node4
            └── third_depth_node3
                └── 0 -> 1

------------------------------
.

------------------------------
.
└── 0 -> 1

------------------------------
.
├── 0 -> T
├── 1 -> Ta
├── 2 -> Tad
├── 3 -> Tada
├── 4 -> Tadav
├── 5 -> Tadavo
├── 6 -> Tadavom
├── 7 -> Tadavomn
├── 8 -> Tadavomni
├── 9 -> Tadavomnis
└── 10 -> TadavomnisT