class TreapBasedSequenceStructure:
'''
Data structure for sequence of y_1jk, y_2jk, ..., y_njk based on balanced binary search trees
'''
def __init__(self):
self.treap = Treap()
def get_sum(self):
'''
Returns a sum of inserted elements (subtree_sum of the root node of a tree)
'''
return 0.0 if self.treap.root == -1 else self.treap.nodes[
self.treap.root].subtree_sum
def insert(self, element):
'''
Inserts a new element (insertion order is not important)
'''
self.treap.add_element(element)
def get_modelling_sum(Y, n):
'''
Returns approximation of the sum of distances required for next combined result modelling
'''
ret = 0.0
for cell in Y:
for c in cell.keys():
s = cell[c].get_sum()
lc, ls = cell[c].treap.get_lower(cell[c].treap.root, s / n)
ret += s * lc - n * ls
# quickly computed approximation of GLD
ret /= (n * (n + 1))
# post-summation normalization: a rough approximation of normalized GLD
return 2 * ret / (ret + 2 * len(Y))
def add(self, i):
t = self.treap
if t:
from random import randint
p = randint(0,100)
self.treap = t.add(Treap, Treap(p,i))
else:
self.treap = Treap.make_treap(Treap, [i])
def heightrandom():
for i in range(2, 10, 2):
L = [100 * random() for x in range((2**i) - 1)]
BSTTree = BST()
TreapTree = Treap()
for x in L:
BSTTree.insert(x)
TreapTree.insert(x)
print("Complete Tree would have height of", i - 1)
print("Height of BST is: ", BSTTree.height())
print("Height of Treap is: ", TreapTree.height())
def __insert(node, value, priority=None):
if node is None:
return TreapNode(value, priority)
if node.value < value:
node.right = MutableTreap.__insert(node.right, value, priority)
if node.right.priority > node.priority:
node = Treap.__rotateLeft(node)
else:
node.left = MutableTreap.__insert(node.left, value, priority)
if node.left.priority > node.priority:
node = Treap.__rotateRight(node)
return node
def __insert(node, value, priority=None):
if node is None:
return TreapNode(value, priority)
if node.value < value:
node.right = MutableTreap.__insert(node.right, value, priority)
if node.right.priority > node.priority:
node = Treap.__rotateLeft(node)
else:
node.left = MutableTreap.__insert(node.left, value, priority)
if node.left.priority > node.priority:
node = Treap.__rotateRight(node)
return node
def __delete(node, value):
if node.left is None and node.right is None:
node = None
elif node.value > value:
node.left = MutableTreap.__delete(node.left, value)
elif node.value < value:
node.right = MutableTreap.__delete(node.right, value)
elif Treap.cmp(node.left, node.right) > 0:
node = Treap.__rotateLeft(node)
node.left = MutableTreap.__delete(node.left, value)
else:
node = Treap.__rotateRight(node)
node.right = MutableTreap.__delete(node.right, value)
return node
def __delete(node, value):
if node.left is None and node.right is None:
node = None
elif node.value > value:
node.left = MutableTreap.__delete(node.left, value)
elif node.value < value:
node.right = MutableTreap.__delete(node.right, value)
elif Treap.cmp(node.left, node.right) > 0:
node = Treap.__rotateLeft(node)
node.left = MutableTreap.__delete(node.left, value)
else:
node = Treap.__rotateRight(node)
node.right = MutableTreap.__delete(node.right, value)
return node
def astar(handle1, handle2):
list_open = Treap() #Prioritätenwarteschlange
list_closed = []
# Initialisierung der Open List, die Closed List ist noch leer
# (die Priorität bzw. der f-Wert des Startknotens ist unerheblich)
list_open.insert(xx, 0) #Todo node
# diese Schleife wird durchlaufen bis entweder
# - die optimale Lösung gefunden wurde oder
# - feststeht, dass keine Lösung existiert
while not list_open.empty():
# Knoten mit dem geringsten f-Wert aus der Open List entfernen
currentNode = list_open.remove_min() #todo check for return
# Der aktuelle Knoten soll durch nachfolgende Funktionen
# nicht weiter untersucht werden, damit keine Zyklen entstehen
list_closed.append(currentNode)
# Wurde das Ziel gefunden?
if currentNode == zielknoten:
return list_closed
# Wenn das Ziel noch nicht gefunden wurde: Nachfolgeknoten
# des aktuellen Knotens auf die Open List setzen
expandNode(currentNode)
# die Open List ist leer, es existiert kein Pfad zum Ziel
return None
def recover(self):
treap = Treap.make_treap(Treap, range(1, len(self.hints)+1))
res = []
for hint in reversed(self.hints):
node = treap.k_th(treap.size()-1-hint)
treap = treap.delete_val(node.val)
res.insert(0, node.val)
return res
class Node:
predecessor = None
tentative_g = None
def __heuristic__(handle1, handle2):
print("Not implemented!")
#todo: Propinquity analysis
#todo: last 200 tweets fetchen
# similiarity check using fasttext
def heuristic():
print("Not implemented!")
#todo
def __getFriends__():
#todo
def successors():
#todo
list_open = Treap() #Prioritätenwarteschlange
list_closed = []
def astar(handle1, handle2):
list_open = Treap() #Prioritätenwarteschlange
list_closed = []
# Initialisierung der Open List, die Closed List ist noch leer
# (die Priorität bzw. der f-Wert des Startknotens ist unerheblich)
list_open.insert(xx, 0) #Todo node
# diese Schleife wird durchlaufen bis entweder
# - die optimale Lösung gefunden wurde oder
# - feststeht, dass keine Lösung existiert
while not list_open.empty():
# Knoten mit dem geringsten f-Wert aus der Open List entfernen
currentNode = list_open.remove_min() #todo check for return
# Der aktuelle Knoten soll durch nachfolgende Funktionen
# nicht weiter untersucht werden, damit keine Zyklen entstehen
list_closed.append(currentNode)
# Wurde das Ziel gefunden?
if currentNode == zielknoten:
return list_closed
# Wenn das Ziel noch nicht gefunden wurde: Nachfolgeknoten
# des aktuellen Knotens auf die Open List setzen
expandNode(currentNode)
# die Open List ist leer, es existiert kein Pfad zum Ziel
return None
# überprüft alle Nachfolgeknoten und fügt sie der Open List hinzu, wenn entweder
# - der Nachfolgeknoten zum ersten Mal gefunden wird oder
# - ein besserer Weg zu diesem Knoten gefunden wird
def expandNode(currentNode):
for #successor of currentNode:
def __delete(node, value):
if node.left is None and node.right is None:
return None
new = TreapNode(node=node)
if node.value > value:
new.left = ImmutableTreap.__delete(new.left, value)
elif node.value < value:
new.right = ImmutableTreap.__delete(new.right, value)
elif Treap.cmp(node.left, node.right) > 0:
new.right = TreapNode(node=new.right)
new = Treap.__rotateLeft(new)
new.left = ImmutableTreap.__delete(new.left, value)
else:
new.left = TreapNode(node=new.left)
new = Treap.__rotateRight(new)
new.right = ImmutableTreap.__delete(new.right, value)
return new
class MedianFinder:
def __init__(self):
self.treap = Treap()
self.histogram = {}
def addItem(self, item):
if item > 0:
self.treap.insert(item)
self.histogram[item] = self.histogram.get(item, 0) + 1
def delItem(self, item):
if item > 0:
self.treap.delete(item)
self.histogram[item] -= 1
def updateItem(self, item, delta):
self.delItem(item)
self.addItem(item+delta)
def findMedian(self):
return self.treap.median()
def solve(n, shifted):
arr = [0 for _ in range(n)]
#1~N까지의 숫자를 모두 저장하는 트립을 만든다.
candidates = Treap()
for i in range(n):
candidates.insert(i + 1)
#뒤에서부터 arr[]를 채워나간다.
for i in range(n - 1, -1, -1):
#후보 중 이 수보다 큰 수가 larger개 있다.
larger = shifted[i]
k = candidates.findKth(i + 1 - larger)
arr[i] = k.key
candidates.delete(k.key)
return arr
def __init__(self):
self.treap = Treap()
self.histogram = {}
def __init__(self):
self.treap = Treap()
def test_removeMoreThanOneOccurence():
t = Treap()
t.insert("A")
t.insert("A")
t.remove("A")
assert t.getOccurenceCount("A") == 1
def test_makeEmptyTreap():
t = Treap()
assert t
def test_removeWithOneOccurence():
t = Treap()
t.insert("A")
t.remove("A")
assert t.find("A") == False
def test_testOccurenceCountMany():
t = Treap()
t.insert("A")
t.insert("A")
t.insert("A")
assert t.getOccurenceCount("A") == 3
def test_findKeyNotThere():
t = Treap()
t.insert("A")
assert t.find("B") == False
def test_findKeyThere():
t = Treap()
t.insert("A")
assert t.find("A")
def test_insertOne():
t = Treap()
assert t.insert("A")
def __init__(self):
Treap.__init__(self)
self.root = None
def __init__(self):
Treap.__init__(self)
self.root = None
def get_nodes_from_vert(vert):
nodes = []
for node in vert.content:
nodes.append(node)
return nodes
nodes = [10, 13, 35, 64, 92, 1231, 1234, 5, 6, 45, 56, 67, 78, 89, 90]
keys = [1, 1, 5, 2, 3, 4, 6, 4, 10, 5, 6, 7, 8, 9, 10]
root_node = 0
root_key = 0
# Constructor test
tree = Treap()
tree.insert(root_node, root_key)
# insert function test
for i in range(len(nodes)):
tree.insert(nodes[i], keys[i])
tree.print_tree()
# locate test
print(tree.locate(10).content) # Single match
print(tree.locate(1).content) # Multiple matches
print('\n')
# TreapVertex test
print(tree.root)
key_5 = tree.locate(5)
