# coding:utf-8

# 列表嵌套法
def BinaryTree(r):
	return [r, [], []]


def insertLeft(root, newBranch):
	t = []
	if root != []:
		t = root.pop(1)
	if len(t) > 1:
		root.insert(1, [newBranch, t, []])
	else:
		root.insert(1, [newBranch, [], []])
	return root


def insertRight(root, newBranch):
	t = []
	if root != []:
		t = root.pop(2)
	if len(t) > 1:
		root.insert(2, [newBranch, [], t])
	else:
		root.insert(2, [newBranch, [], []])
	return root


def getRootVal(root):
	return root[0]


def setRootVal(root, newVal):
	root[0] = newVal


def getLeftChild(root):
	return root[1]


def getRightChild(root):
	return root[2]


if __name__ == ‘__main__‘:
	r = BinaryTree(‘a‘)
	insertLeft(r, ‘b‘)
	insertRight(r, ‘c‘)
	insertRight(getLeftChild(r), ‘d‘)
	insertLeft(getRightChild(getRightChild(r)), ‘e‘)
	print(r)

class BinaryTree:
    """
    A recursive implementation of Binary Tree
    Using links and Nodes approach.

    Modified to allow for trees to be constructed from other trees rather than always creating
    a new tree in the insertLeft or insertRight
    """

    def __init__(self,rootObj):
        self.key = rootObj
        self.leftChild = None
        self.rightChild = None

    def insertLeft(self,newNode):

        if isinstance(newNode, BinaryTree):
            t = newNode
        else:
            t = BinaryTree(newNode)

        if self.leftChild is not None:
            t.left = self.leftChild

        self.leftChild = t

    def insertRight(self,newNode):
        if isinstance(newNode,BinaryTree):
            t = newNode
        else:
            t = BinaryTree(newNode)

        if self.rightChild is not None:
            t.right = self.rightChild
        self.rightChild = t

    def isLeaf(self):
        return ((not self.leftChild) and (not self.rightChild))

    def getRightChild(self):
        return self.rightChild

    def getLeftChild(self):
        return self.leftChild

    def setRootVal(self,obj):
        self.key = obj

    def getRootVal(self,):
        return self.key

    def inorder(self):
        if self.leftChild:
            self.leftChild.inorder()
        print(self.key)
        if self.rightChild:
            self.rightChild.inorder()

    def postorder(self):
        if self.leftChild:
            self.leftChild.postorder()
        if self.rightChild:
            self.rightChild.postorder()
        print(self.key)


    def preorder(self):
        print(self.key)
        if self.leftChild:
            self.leftChild.preorder()
        if self.rightChild:
            self.rightChild.preorder()

    def printexp(self):
        if self.leftChild:
            print(‘(‘, end=‘ ‘)
            self.leftChild.printexp()
        print(self.key, end=‘ ‘)
        if self.rightChild:
            self.rightChild.printexp()
            print(‘)‘, end=‘ ‘)

    def postordereval(self):
        opers = {‘+‘:operator.add, ‘-‘:operator.sub, ‘*‘:operator.mul, ‘/‘:operator.truediv}
        res1 = None
        res2 = None
        if self.leftChild:
            res1 = self.leftChild.postordereval()  #// \label{peleft}
        if self.rightChild:
            res2 = self.rightChild.postordereval() #// \label{peright}
        if res1 and res2:
            return opers[self.key](res1,res2) #// \label{peeval}
        else:
            return self.key

def inorder(tree):
    if tree != None:
        inorder(tree.getLeftChild())
        print(tree.getRootVal())
        inorder(tree.getRightChild())

def printexp(tree):
    if tree.leftChild:
        print(‘(‘, end=‘ ‘)
        printexp(tree.getLeftChild())
    print(tree.getRootVal(), end=‘ ‘)
    if tree.rightChild:
        printexp(tree.getRightChild())
        print(‘)‘, end=‘ ‘)

def printexp(tree):
    sVal = ""
    if tree:
        sVal = ‘(‘ + printexp(tree.getLeftChild())
        sVal = sVal + str(tree.getRootVal())
        sVal = sVal + printexp(tree.getRightChild()) + ‘)‘
    return sVal

def postordereval(tree):
    opers = {‘+‘:operator.add, ‘-‘:operator.sub, ‘*‘:operator.mul, ‘/‘:operator.truediv}
    res1 = None
    res2 = None
    if tree:
        res1 = postordereval(tree.getLeftChild())  #// \label{peleft}
        res2 = postordereval(tree.getRightChild()) #// \label{peright}
        if res1 and res2:
            return opers[tree.getRootVal()](res1,res2) #// \label{peeval}
        else:
            return tree.getRootVal()

def height(tree):
    if tree == None:
        return -1
    else:
        return 1 + max(height(tree.leftChild),height(tree.rightChild))