Бинарное дерево навигации

Question

Мне было интересно, какие функции я мог бы добавить в свой инструмент навигации Binary Tree в Python.Пожалуйста, помните, что я всего лишь студент AS, поэтому не стоит слишком усердно писать мой код.

class Node:

    Depth = 0
    Table = []
    Max = 0

    def __init__(self, depth, value):
        self.Value = value
        if len(str(self.Value)) > Node.Max:
            Node.Max = len(str(self.Value))
        self.Right = None
        self.Left = None
        self.Depth = depth

    def lor(self, place):
        if place <= self.Value:
            if self.Left is None:
                if self.Depth + 1 > Node.Depth:
                    Node.Depth = self.Depth+1
                self.Left = Node(self.Depth+1, place)
            else:
                self.Left.lor(place)

        elif place > self.Value:
            if self.Right is None:
                if self.Depth + 1 > Node.Depth:
                Node.Depth = self.Depth + 1
                self.Right = Node(self.Depth + 1, place)
            else:
                self.Right.lor(place)
        Node.Table = return_table(Node.Depth)

    def output(self):
        if self.Left is None and self.Right is None:
            print(self.Value, end=" ")
        else:
            if self.Left is not None:
                self.Left.output()
            print(self.Value, end=" ")
            if self.Right is not None:
                self.Right.output()

    def placeInTab(self, LR, prev_col):
        if LR == "L":
            reduc = 0
            while True:
                if Node.Table[self.Depth-1][prev_col - reduc] == "Y"*Node.Max:
                    self.ValidateLen()
                    Node.Table[self.Depth-1][prev_col - reduc] = str(self.Value)
                    self.index = prev_col - reduc
                    break
                else:
                    reduc += 1
        if LR == "R":
            reduc = 0
            while True:
                if Node.Table[self.Depth-1][prev_col + reduc] == "Y"*Node.Max:
                    self.ValidateLen()
                    Node.Table[self.Depth-1][prev_col + reduc] = str(self.Value)
                    self.index = prev_col + reduc
                    break
                else:
                    reduc += 1

    def PlaceLR(self):
        if self.Left is not None:
            self.Left.placeInTab("L", self.index)
            self.Left.PlaceLR()
        if self.Right is not None:
            self.Right.placeInTab("R", self.index)
            self.Right.PlaceLR()

    def placeStart(self):
        for self.index in range(len(Node.Table[0])):
            if Node.Table[0][self.index] == "Y"*Node.Max:
                self.ValidateLen()
                Node.Table[0][self.index] = str(self.Value)
                break

        self.PlaceLR()

    def ValidateLen(self):
        if len(str(self.Value)) < Node.Max:
            self.Value = ("0"*(Node.Max-len(str(self.Value))))+str(self.Value)


def create_table(depth, width, Max):
    table = []
    for rows in range(depth):
        temp_list = []
        for column in range(width):
            temp_list.append(" "*Max)
        table.append(temp_list)
    return table


def create_base(table, Max):
    switch = True
    for pos in range(len(table[0])):
        if switch is True:
            table[0][pos] = "Y"*Max
            switch = False
        else:
            switch = True
    return table


def Gen_Layers(table, Max):
    for prev_row in range(0, len(table)-1):
        y1f = False
        y1 = 0
        y2f = False
        y2 = 0
        for col in range(len(table[prev_row])):
            if y1f is False:
                if table[prev_row][col] == "Y"*Max:
                    y1 = col
                    y1f = True
            else:
                if table[prev_row][col] == "Y"*Max:
                    y2 = col
                    y2f = True

            if y2f is True and y1f is True:
                table[prev_row + 1][int((y1+y2)/2)] = "Y"*Max
                y1f, y2f = False, False
    return table


def return_table(depth):               
    table = Gen_Layers(create_base(create_table(depth,(2**depth)-1, Node.Max), Node.Max), Node.Max)
    table.reverse()
    return table


def format_table(table, Max):
    for x in range(len(table)):
        for y in range(len(table[x])):
            if table[x][y] == str("Y"*Max):
                table[x][y] = "_"*Max
    return table


def clean_table(table, Max):
    new_table = []
    for row in table:
        new_table.append([])
    for index in range(len(table[0])):
        for depth in range(len(table)):
            if table[depth][index] not in [" "*Max, "_"*Max]:
                for row in range(len(table)):
                    new_table[row].append(table[row][index])
    return new_table


x = [23, 54, 23, 5, 7, 5, 3, 34, 6, 5, 7, 32, 3, 23, 65, 43, 21]
start = Node(1, x[0])
for pos in range(1, len(x)):
    start.lor(x[pos])

start.output()
print("\nDepth:", Node.Depth)

print("\n\n")

start.placeStart()
Node.Table = format_table(Node.Table, Node.Max)
for x in Node.Table:
    print("".join(x))

Я подумал, может быть, добавив способ упростить внешний вид создаваемого дерева или каким-то образомпоказывая генерируемое дерево.

Мне также интересно, есть ли более эффективный способ создания шаблона дерева.