C[omp]ute

From: andrew cooke <andrew@...>

Date: Mon, 13 May 2013 11:16:42 -0400

This was preliminary work for the StackOverflow answer at
http://stackoverflow.com/questions/11096134/print-a-binary-tree-on-its-side/16680023#16680023
- I did it while on holiday (installed Python on Mum's laptop :o) and then
posted the answer when I got home.  I have modified these posts since first
writing them to improve the code and explanation a little.

To be honest, it's not very exciting code - just careful bookkeeping and the
kind of recursive approach you'd expect, merging results from sub-trees.

Here are some results (I've named the leaves according to their location,
which helps understand what is happening, I hope):

 5 nodes
    /rr
   /\rl
  / /lrr
  \/\lrl
   \ll

 20 nodes
	    /rrrrr
	   /\rrrrl
	  /\rrrl
	 /\/rrlr
	/  \rrll
       /   /rlrrr
      /\  /\/rlrrlr
     /  \/\ \rlrrll
    /    \ \rlrl
   /      \/rllr
  /        \rlll
  \        /lrrrr
   \      /\lrrrl
    \    /\lrrl
     \  / /lrlr
      \/\/ /lrllrr
       \ \/\lrllrl
	\ \lrlll
	 \/llr
	  \lll

And the code follows.

Andrew



#!/usr/local/bin/python3.3

from itertools import chain
from random import randint


# first, some support routines.  these assume that a tree is either a string
# leaf value, or a tuple (pair) of subnodes.

def leaf(t):
    '''is the given node a leaf?'''
    return isinstance(t, str)

def random(n):
    '''generate a random tree with n nodes (n > 1)'''
    def extend(t):
        if leaf(t):
            return (t+'l', t+'r')
        else:
            l, r = t
            if randint(0, 1): return (l, extend(r))
            else: return (extend(l), r)
    t = ''
    for _ in range(n-1): t = extend(t)
    return t


# next, the formatting itself.  this is not that exciting - a recursive 
# descent to the leaves and then a merging of sub-trees on the returns.
# the hard part is just the book-keeping.

def format(t):
    '''format the tree (returns a multi-line string reprn)'''

    def pad(label, prefix, spaces, previous):
        '''add spaces between / (or \) and the previous line contents.
           change ' ' to label to see what logic is used where'''
        return prefix + (' ' * spaces) + previous

    def merge(l, r):
        '''merges the two sub-trees to generate the fragment for the
           combined node.  a fragment is (above, below, lines) where
           above is number of lines above root, below below root, and
           lines is an iterator over each partial line.'''
        l_above, l_below, l_lines = l
        r_above, r_below, r_lines = r
        gap = r_below + l_above
        gap_above = l_above  # this balances the result (see post text)
        gap_below = gap - gap_above

        def lines():
            '''the actual mergin of lines.  there are six different cases,
               handled in turn.'''
            for (i, line) in enumerate(chain(r_lines, l_lines)):
                if i < r_above:
                    # we already have 'sloped' data above where we are joining
                    yield line
                elif i - r_above < gap_above:
                    # we are in the upper branch region, joined by a / symbol
                    if i < r_above + r_below:
                        # are we filling the increasing gap between the new 
                        # / branch and the existing tree that has a \ shaped 
                        # boundary?
                        yield pad('A', '/', 2 * (i - r_above), line)
                    else:
                        # or are we in the constant sized gap between the 
                        # new / branch and the upper / shaped boundary of the 
                        # lower sub-node?
                        yield pad('B', '/', 2 * gap_below - 1, line)
                elif i - r_above - gap_above < gap_below:
                    # we are in the lower branch region, joined by a \ symbol
                    if i < r_above + r_below:
                        # are we overlapping the \ shaped boundary of the 
                        # upper sub-node?
                        yield pad('C', '\\', 2 * gap_above - 1, line)
                    else:
                        # or are we in the gap between the new \ and the 
                        # / shaped edge of the lower sub-node?
                        spaces = 2 * (r_above + gap_above + gap_below - i - 1)
                        yield pad('D', '\\', spaces, line)
                else:
                    # we already ave 'sloped' data below where we are joining
                    yield line
        return (r_above + gap_above, gap_below + l_below, lines())

    def descend(left, t):
        '''descend to leaf nodes, where we know what the fragments are
           (just the leaf contents) and then merge nodes on return.'''
        if leaf(t):
            if left:
                return (1, 0, [t])
            else:
                return (0, 1, [t])
        else:
            l, r = t
            return merge(descend(True, l), descend(False, r))

    def flatten(t):
        '''add left-hand spacing to the final tree.'''
        above, below, lines = t
        for (i, line) in enumerate(lines):
            if i < above: yield (' ' * (above - i - 1)) + line
            else: yield (' ' * (i - above)) + line

    # put it all together...
    return '\n'.join(flatten(descend(True, t)))


if __name__ == '__main__':
    for n in range(1,20,3):
        tree = random(n)
        print(tree)
        print(format(tree))