from collections import deque
class Node(object):
# __init__ :: T(A)
def __init__(self, value=None, left=None, right=None):
self.value = value
self.left = left
self.right = right
# insert_left :: T(A) -> A -> T(A)
def insert_left(self, value):
self.left = Node(value)
return self.left
# insert_right :: T(A) -> A -> T(A)
def insert_right(self, value):
self.right = Node(value)
return self.right
# is_superbalanced :: T(A) -> Bool
def is_superbalanced(self):
xs = deque()
min_depth, max_depth = float('inf'), float('-inf')
xs.append((self, 0))
while xs:
x, d = xs.popleft()
# Only redefine the depths at leaf nodes
if not x.left and not x.right:
min_depth, max_depth = min(min_depth, d), max(max_depth, d)
if x.left:
xs.append((x.left, d + 1))
if x.right:
xs.append((x.right, d + 1))
return max_depth - min_depth <= 1
# __repr__ :: T(A) -> String
def __repr__(self):
result = ''
xs = deque()
xs.append((self, 0))
while xs:
node, indent = xs.popleft()
result += '{i}{x}\n'.format(i=' ' * indent, x=node.value)
if node.left:
xs.append((node.left, indent + 2))
if node.right:
xs.append((node.right, indent + 2))
return result
# from_array :: List(A) -> T(A)
def from_array(values):
xs = deque()
root = Node()
xs.append(root)
for value in values:
node = xs.popleft()
node.value = value
node.left = Node()
xs.append(node.left)
node.right = Node()
xs.append(node.right)
return root
x = from_array([1, 1, 1, 1, 1, 1, 1])
print(x)
print(x.is_superbalanced())
x = Node(1, Node(2), Node(3))
print(x)
print(x.is_superbalanced())
