binary tree

# Modified version of the code found here:
# http://bit.ly/2tBY3RY
class Node:
    def __init__(self, val):
        self.l = None
        self.r = None
        self.v = val

class Tree:
    def __init__(self):
        self.root = None

    def getRoot(self):
        return self.root

    def add(self, val):
        if(self.root == None):
            self.root = Node(val)
        else:
            self._add(val, self.root)

    def _add(self, val, node):
        if(val < node.v):
            if(node.l != None):
                self._add(val, node.l)
            else:
                node.l = Node(val)
        else:
            if(node.r != None):
                self._add(val, node.r)
            else:
                node.r = Node(val)

    # Inorder
    def printTree(self):
        if(self.root != None):
            self._printTree(self.root)

    def _printTree(self, node):
        if(node != None):
            self._printTree(node.l)
            print str(node.v) + ' '
            self._printTree(node.r)

    def postOrder(self):
        if self.root is not None:
            self._postOrder(self.root)

    def _postOrder(self, node):
        if node is not None:
            self._postOrder(node.l)
            self._postOrder(node.r)
            print str(node.v) + ' '

    def relable(self, h):
        hh = get_max_node(h)
        if self.root is not None:
            self._relable(self.root, hh)

    def _relable(self, node, h):
        if node is not None:
            self._relable(node.l, h-2)
            self._relable(node.r, h-1)
            node = Node(h)


def get_max_node(h):
    return 2**(h)-1

def answer(h, q):
    max = get_max_node(h)
    tree = Tree()
    for i in range(1, max+1):
        tree.add(i)
    #tree.printTree()
    return tree

tree = answer(3, [1, 4, 7])
#tree.printTree()
tree.relable(3)
tree.postOrder()