def avl_insert(string):
start = time.clock()
avl = AVLTree()
for i in range(num):
avl.insert(i)
end = time.clock()
print string + str(end - start)
def avl_search(string):
avl = AVLTree()
for i in range(num):
avl.insert(i)
start = time.clock()
for i in range(num):
avl.find(i)
end = time.clock()
print string + str(end - start)
def test_insert_with_7_items(self):
# Create a complete binary search tree of 7 items in level-order
items = [4, 2, 6, 1, 3, 5, 7]
tree = AVLTree()
for item in items:
tree.insert(item)
assert tree.root.data == 4
assert tree.root.left.data == 2
assert tree.root.right.data == 6
assert tree.root.left.left.data == 1
assert tree.root.left.right.data == 3
assert tree.root.right.left.data == 5
assert tree.root.right.right.data == 7
class TestAVLTree(unittest.TestCase):
def setUp(self):
self.avl = None
def _initialize(self):
self._cleanup()
self.avl = AVLTree()
lst = [5, 8, 2, 1, 3, 9, 7, 4, 6, 0]
for i in lst:
self.avl.insert(i)
# verify length and that root node is 5
self.assertEqual(len(self.avl), 10)
self.assertEqual(self.avl.root.value, 5)
def _cleanup(self):
if self.avl:
del(self.avl)
self.avl = None
def test_insert(self):
self._initialize()
self._cleanup()
def test_delete(self):
self._initialize()
self.avl.delete(5)
# length should be 9 and root should be 6 (instead of 5)
self.assertEqual(len(self.avl), 9)
self.assertEqual(self.avl.root.value, 6)
self._cleanup()
def test_iteration(self):
self._initialize()
lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in self.avl.root:
self.assertTrue(i == lst[i])
self._cleanup()
def tearDown(self):
self._cleanup()
class AVLRangeIndex(object):
"""AVL Tree-based range index implementation."""
def __init__(self):
self.data = AVLTree()
def add(self, key):
if key is None:
raise ValueError('Cannot insert nil in the index')
self.data.insert(key)
def remove(self, key):
self.data.delete(key)
def list(self, first_key, last_key):
return self.data.as_list(first_key, last_key)
def count(self, first_key, last_key):
result = len(self.as_list(first_key, last_key))
return result
def test_size(self):
tree = AVLTree()
assert tree.size == 0
tree.insert('B')
assert tree.size == 1
tree.insert('A')
assert tree.size == 2
tree.insert('C')
assert tree.size == 3
def test_insert_with_3_items(self):
# Create a complete binary search tree of 3 items in level-order
tree = AVLTree()
tree.insert(2)
assert tree.root.data == 2
assert tree.root.left is None
assert tree.root.right is None
tree.insert(1)
assert tree.root.data == 2
assert tree.root.left.data == 1
assert tree.root.right is None
tree.insert(3)
assert tree.root.data == 2
assert tree.root.left.data == 1
assert tree.root.right.data == 3
from avltree import AVLTree #from binarytree import BinaryTree tree = AVLTree() #tree = BinaryTree() tree.insert(1) tree.insert(2) tree.insert(3) tree.insert(4) tree.insert(5) tree.insert(6) tree.insert(7) tree.insert(8) tree.preorder() #tree.postorder()
class OrderTree(object):
def __init__(self):
self.price_tree = AVLTree()
self.price_map = {}
self.order_map = {}
self.volume = 0
self.num_orders = 0
self.depth = 0
def __len__(self):
return len(self.order_map)
def get_price_list(self, price):
return self.price_map[price]
def get_order(self, order_id):
return self.order_map[order_id]
def create_price(self, price):
self.depth += 1
new_list = OrderList()
self.price_tree.insert(price, new_list)
self.price_map[price] = new_list
def remove_price(self, price):
self.depth -= 1
self.price_tree.remove(price)
del self.price_map[price]
def price_exists(self, price):
return price in self.price_map
def order_exist(self, order):
return order in self.order_map
def insert_order(self, quote):
if self.order_exist(quote['order_id']):
self.remove_order_by_order_id(quote['order_id'])
self.num_orders += 1
if quote['price'] not in self.price_map:
self.create_price(quote['price'])
order = Order(quote, self.price_map[quote['price']])
self.price_map[order.price].append_order(order)
self.order_map[order.order_id] = order
self.volume += order.quantity
def remove_order_by_order_id(self, order_id):
self.num_orders -= 1
order = self.order_map[order_id]
self.volume -= order.quantity
order.order_list.remove_order(order)
if len(order.order_list) == 0:
self.remove_price(order.price)
del self.order_map[order_id]
def max_price(self):
if self.depth > 0:
return self.price_tree.max_key()
else:
return None
def min_price(self):
if self.depth > 0:
return self.price_tree.min_key()
else:
return None
def max_price_list(self):
if self.depth > 0:
return self.get_price_list(self.max_price())
else:
return None
def min_price_list(self):
if self.depth > 0:
return self.get_price_list(self.min_price())
else:
return None
