def huffman(C):
n = len(C)
Q = _build_min_priority_queue(C)
for i in between(1, n - 1):
z = Node(None)
z.left = x = _heap_extract_min(Q)
z.right = y = _heap_extract_min(Q)
z.f = x.f + y.f
_min_heap_insert(Q, z)
return _heap_extract_min(Q)
def _build_min_priority_queue(C):
nodes = []
for c in C:
node = Node(None)
node.data = c[0]
node.f = c[1]
nodes.append(node)
A = Array(nodes)
_build_min_heap(A)
return A
def _balance_node(x, A, p, r):
if p <= r:
q = (p + r) // 2
y = Node(A[q])
y.left = _balance_node(y, A, p, q - 1)
y.right = _balance_node(y, A, q + 1, r)
y.p = x
y.size = 1
y.size += y.left.size if y.left is not None else 0
y.size += y.right.size if y.right is not None else 0
return y
return None
def test_create_binary_tree(self):
left = Node(3)
right = Node(20)
root = Node(17, left=left, right=right)
tree = BinaryTree(root)
assert_that(tree.root, is_(root))
assert_that(root.left, is_(left))
assert_that(root.right, is_(right))
assert_that(left.left, is_(none()))
assert_that(left.right, is_(none()))
assert_that(right.left, is_(none()))
assert_that(right.right, is_(none()))
assert_parent_pointers_consistent(tree)
def test_recursive_tree_insert(self):
keys = [random.randrange(1000) for _ in range(20)]
tree = BinaryTree()
for key in keys:
recursive_tree_insert_wrapper(tree, Node(key))
assert_binary_search_tree(tree)
assert_parent_pointers_consistent(tree)
actual_keys = get_binary_tree_keys(tree)
assert_that(actual_keys, contains_inanyorder(*keys))
def _balance_node(x, A, p, r):
if p <= r:
q = (p + r) // 2
y = Node(A[q])
y.left = _balance_node(y, A, p, q - 1)
y.right = _balance_node(y, A, q + 1, r)
y.p = x
y.size = 1
y.size += y.left.size if y.left is not None else 0
y.size += y.right.size if y.right is not None else 0
return y
return None
def inorder_sort(A):
T = BinaryTree()
for i in between(1, A.length):
tree_insert(T, Node(A[i]))
inorder_tree_walk(T.root)
def setUp(self):
self.tree = BinaryTree(
Node(10,
left=Node(4, left=Node(1)),
right=Node(14, left=Node(11), right=Node(19,
right=Node(20)))))