Python Binary Tree

btree.py

import math
import multiprocess as mp

class btree:
    def __init__(self, height):
        self.hieght = height
        self.node_values = btree.calc_node_values(height)
        self.index = 1
        self.head = None
        self.build()
        self.parent = None
        self.found = []
    
    @staticmethod        
    def calc_node_values(height = 0):
        count = 0
        total = 0
        for x in range(height):
            if (x == 0):
                count = 1
            else:
                count = count * 2
            
            total += count
            
        return [i + 1 for i in range(total)]
    
    @staticmethod
    def get_leaf(value):
        leaf =  {}
        leaf['value'] = value
        leaf['left'] = None
        leaf['right'] = None
        leaf['label'] = None
        
        return leaf
    
    @staticmethod
    def get_midpoint(values):
        if len(values) > 0:
            mp = int(math.ceil(len(values)  / 2)) or 1
            mid = values[mp - 1 : mp][0]
        
            if mp > 1:
                left = values[0 : mp - 1]
                right = values[mp : len(values)]
            else:
                left = []
                right = []
                
            return (
                mid, 
                left, 
                right)
        else:
            return [None]
    
    def build(self):
        mp = btree.get_midpoint(self.node_values)
        self.head = self.get_leaf(mp[0])
        
        self.add(mp[1], self.head)
        self.add(mp[2], self.head)
            
    def add(self, values, node):
        mp = btree.get_midpoint(values)
        child = btree.get_leaf(mp[0])
        
        if mp[0] != None:
            if mp[0] < node['value']:
                node['left'] = child
            else:
                node['right'] = child
            if(len(mp[1]) > 0 and len(mp[2]) > 0):
                self.add(mp[1], child)
                self.add(mp[2], child)
    
    def label_post_order(self, node):
        if (node != None):
            self.label_post_order(node['left'])
            self.label_post_order(node['right'])
            node['label'] = self.index
            self.index += 1
            
    def find(self, node, value):
        if (node != None):
            if node['label'] == value:
                self.found.append(-1)
                return
            if node['left']:
                if node['left']['label'] == value:
                    self.found.append(node['label'])
                    return
            
            if node['right']:
                if node['right']['label'] == value:
                    self.found.append(node['label'])
                    return
                    
            self.find(node['left'], value)
            self.find(node['right'], value)
            
            
        
            
def answer(h, q):
    bt = btree(h)
    bt.label_post_order(bt.head)
    results = []
    
    for x in q:
        bt.find(bt.head, x)
        
    return bt.found