def testRandomSID():
# Initialize data structures.
bst = BinarySearchTree()
# Generate sample sets:
(s, i, d) = generateRandomSIDSampleSet(210, 40, 10, 40)
bm = SIDBenchmark(
bst.search,
bst.insert,
bst.delete,
s,
i,
d,
# STOP,
210,
# BENCHMARK_START,
40,
# BENCHMARK_LENGTH,
10,
# BENCHMARK_INTERVAL
40)
print("\nSearch plot:")
print(bm.search_plot.coordinates)
print("\nInsert plot:")
print(bm.insert_plot.coordinates)
print("\nDelete plot:")
print(bm.delete_plot.coordinates)
def randomAllSmall():
"""Performs a small random data test on ALL data structures under consideration."""
# Initialize data structures
bst = BinarySearchTree()
stromberg_treap = StrombergTreap()
jenks_treap = JenksTreap()
pyskiplist = PySkipList()
redblacktree = RedBlackTree()
# avltree = AVLTree()
# Custom benchmarking parameters
stop = 5200
bm_start = 200
bm_length = 20
bm_interval = 200
# Final setup, and invocation.
filename = "plots/randomAllSmall.tex"
functions = \
[bst.insert, stromberg_treap.insert, jenks_treap.insert, pyskiplist.insert, redblacktree.add]
samples = generateRandomSamples(stop)
title = "Insert: All Data Structures, Random Input (Small Data Set)"
graph(filename,
functions,
samples,
title=title,
stopindex=stop,
bm_startindex=bm_start,
bm_interval=bm_interval,
bm_length=bm_length,
repeat=1)
def randomAllTinyRepeat():
"""Performs a tiny random data test on ALL data structures under consideration."""
# Initialize data structures
bst = BinarySearchTree()
stromberg_treap = StrombergTreap()
# Custom benchmarking parameters
stop = 1010
bm_start = 100
bm_length = 10
bm_interval = 50
# Final setup, and invocation.
filename = "plots/randomAllTinyRepeat.tex"
functions = [bst.insert, stromberg_treap.insert]
samples = generateRandomSamples(stop)
title = "Insert: All Data Structures, Random Input (Tiny Data Set) - Median of 11 runs"
graph(filename,
functions,
samples,
title=title,
stopindex=stop,
bm_startindex=bm_start,
bm_interval=bm_interval,
bm_length=bm_length,
repeat=11)
def testGraphMixedSID():
# Options and parameters
size = 20
bm_start = 0
bm_length = 3
bm_interval = 5
filename = "plots/testGraphMixedSID.tex"
# Generate operation sequence
ops = generateRandomOperationSequence(size)
# Initialize data structures
bst = BinarySearchTree()
stromberg_treap = StrombergTreap()
jenks_treap = JenksTreap()
pyskiplist = PySkipList()
redblacktree = RedBlackTree()
sortedlist = SortedList()
builtinlist = List()
# Create functions list
searches = \
[
bst.search,
stromberg_treap.get_key,
jenks_treap.__getitem__,
pyskiplist.search,
redblacktree.find_node,
sortedlist.search,
builtinlist.search,
]
inserts = \
[
bst.insert,
stromberg_treap.insert,
jenks_treap.insert,
pyskiplist.insert,
redblacktree.add,
sortedlist.add,
builtinlist.add
]
deletes = \
[
bst.delete,
stromberg_treap.remove,
jenks_treap.__delitem__,
pyskiplist.remove,
redblacktree.remove,
sortedlist.remove,
builtinlist.remove
]
# Run the graph
graphMixedSID(filename, searches, inserts, deletes, ops, bm_start,
bm_length, bm_interval)
def testPgfPlot():
# Create data structures
bst = BinarySearchTree()
mylist = []
# Create samples
inputs = generateRandomSamples(STOP - START)
graph(
"plots/testpgfplot.tex",
[bst.insert, mylist.append],
inputs,
xlabel="TEST X LABEL",
ylabel="TEST Y LABEL",
title="TEST TITLE",
)
def insertRandom():
"""Performs a small random data test on ALL data structures under consideration."""
# Initialize data structures
bst = BinarySearchTree()
stromberg_treap = StrombergTreap()
jenks_treap = JenksTreap()
pyskiplist = PySkipList()
redblacktree = RedBlackTree()
# avltree = AVLTree()
# Final setup, and invocation.
filename = "plots/insertRandom.tex"
functions = \
[bst.insert, stromberg_treap.insert, jenks_treap.insert, pyskiplist.insert, redblacktree.add]
samples = generateRandomSamples(SAMPLE_SIZE)
title = "Insert: Random Input"
graph(filename, functions, samples, title=title)
def randomSID():
"""Performs a full search, insert, and delete benchmark set on randomized input data."""
(search_samples, insert_samples,
delete_samples) = generateRandomSIDSampleSet() # 210, 40, 10, 40)
# Initialize data structures
bst = BinarySearchTree()
stromberg_treap = StrombergTreap()
jenks_treap = JenksTreap()
pyskiplist = PySkipList()
redblacktree = RedBlackTree()
# avltree = AVLTree()
# Final setup, and invocation.
base_filename = "plots/random.tex"
search_filename = base_filename[0:-4] + "_search" + base_filename[-4:]
insert_filename = base_filename[0:-4] + "_insert" + base_filename[-4:]
delete_filename = base_filename[0:-4] + "_delete" + base_filename[-4:]
searches = \
[bst.search, stromberg_treap.get_key, jenks_treap.__getitem__, pyskiplist.search, redblacktree.find_node]
inserts = \
[bst.insert, stromberg_treap.insert, jenks_treap.insert, pyskiplist.insert, redblacktree.add]
deletes = \
[bst.delete, stromberg_treap.remove, jenks_treap.__delitem__, pyskiplist.remove, redblacktree.remove]
title = "Random Input"
graphSID(
search_filename,
insert_filename,
delete_filename,
searches,
inserts,
deletes,
search_samples,
insert_samples,
delete_samples,
# 210,
# 40,
# 10,
# 40,
title=title)
def test_fuzz(self):
"""Perform some basic randomized input testing."""
repeat_times = 5
sample_set = range(-1000, 1001)
bst = BinarySearchTree()
for i in range(repeat_times):
# Insert elements
for j in random.sample(sample_set, len(sample_set)):
bst.insert(j)
# Search for elements
for j in random.sample(sample_set, len(sample_set)):
self.assertEqual(j, bst.search(j))
# Delete elements
for j in random.sample(sample_set, len(sample_set)):
self.assertTrue(bst.delete(j))
self.assertIsNone(bst.search(j))
import random
import sys
sys.path.insert(
1, "C:\Users\Tim\Desktop\competition\clrs\datastructures_old_py2")
from datastructures.binarysearchtree import BinarySearchTree, Node
if __name__ == "__main__":
bst = BinarySearchTree()
keys = range(100)
random.shuffle(keys)
for key in keys:
bst.insert(Node(key))
x = bst.search(50)
print bst.successor(x).key
print bst.predecessor(x).key
return True
last_seen = {"value": -float("inf")}
return check_subtree(binary_tree.root)
def is_binary_search_tree2(binary_tree):
"""Returns True if the given binary tree is in fact a
binary search tree.
"""
in_order_nodes = []
in_order_traversal(in_order_nodes, binary_tree.root)
for i in xrange(len(in_order_nodes) - 1):
if in_order_nodes[i].key > in_order_nodes[i + 1].key:
return False
return True
# return any(in_order_nodes[i].key > in_order_nodes[i + 1].key for i in xrange(len(in_order_nodes) - 1))
def in_order_traversal(node_list, root):
if root is not None:
in_order_traversal(node_list, root.left)
node_list.append(root)
in_order_traversal(node_list, root.right)
if __name__ == "__main__":
bst = BinarySearchTree()
for i in xrange(10):
bst.insert(Node(i))
bst.root.left = Node(999)
print is_binary_search_tree_min_max(bst)
def same_tree2(root1, root2):
q = Queue()
q.enqueue(root1)
q.enqueue(root2)
while not q.queue_empty():
x, y = q.dequeue(), q.dequeue()
if x.key != y.key:
return False
if x.left is not None and y.left is not None:
q.enqueue(x.left)
q.enqueue(y.left)
elif x.left is not y.left:
return False
if x.right is not None and y.right is not None:
q.enqueue(x.right)
q.enqueue(y.right)
elif x.right is not y.right:
return False
return True
if __name__ == "__main__":
t1 = BinarySearchTree()
t2 = BinarySearchTree()
for i in xrange(1000):
t1.insert(Node(i))
print "DONE"
for i in xrange(900, 1000):
t2.insert(Node(i))
print is_subtree(t1, t2)
import datastructures.binarytreeutilities as btutils
from datastructures.binarysearchtree import BinaryTree
from datastructures.binarysearchtree import BinarySearchTree
print("Hello!")
bst = BinarySearchTree()
bst.insert(13)
bst.insert(10)
bst.insert(19)
bst.insert(6)
bst.insert(14)
bst.insert(20)
bst.insert(12)
bst.insert(15)
print(bst.root.data)
print(btutils.get_number_of_leaves(bst.root))
print(btutils.get_printable_tree(bst.root))
def testMixedSIDPlotSizes():
"""Runs a small test that inserts and deletes between benchmarksexpects known values.
The operation sequence is as follows:
1. Insert up to first benchmark.
2. Search through first benchmark.
3. Search up to second benchmark.
4. Insert through second benchmark.
5. Search up to third benchmark.
6. Delete through third benchmark.
7. Search up to fourth benchmark.
8. Insert and delete in equal numbers through fourth benchmark.
Expected values are thus easily determined, I expect a specific plot in return.
For simplicity, the operation between benchmarks is always search, so we don't have to simulate it here at all."""
# Our printed expected values.
expected = []
# Convenience locals
s = [(MixedSIDBenchmarkPlot.SEARCH, 0)]
i = [(MixedSIDBenchmarkPlot.INSERT, 0)]
d = [(MixedSIDBenchmarkPlot.DELETE, 0)]
# Test parameters
bm_start = 4
bm_length = 4
bm_interval = 8
# Get us to the first benchmark
ops = i * bm_start
size = bm_start
index = bm_start
# Run the first simulated benchmark: search.
expected.append((index, size))
ops += s * bm_length
# size does not change.
# Fast forward
index += bm_interval
ops += s * (bm_interval - bm_length)
# Run the second simulated benchmark: insert.
expected.append(
(index, statistics.median(list(range(size + 1,
size + bm_length + 1)))))
ops += i * bm_length
size += bm_length
# Fast forward
index += bm_interval
ops += s * (bm_interval - bm_length)
# Run the third simulated benchmark: delete.
expected.append(
(index,
statistics.median(list(range(size - 1, size - bm_length - 1, -1)))))
ops += d * bm_length
size -= bm_length
# Fast forward
index += bm_interval
ops += s * (bm_interval - bm_length)
# Run the first simulated benchmark: insert and delete equally.
expected += (index, size)
ops += (i + d) * (bm_length // 2)
# size does not change.
# Now, run the real simulation.
sim_plot = MixedSIDBenchmarkPlot.plotSizes(ops, bm_start, bm_length,
bm_interval)
# And just for kicks, run the actual benchmark on these operations.
bst = BinarySearchTree()
real_plot = MixedSIDBenchmarkPlot(ops, bst.search, bst.insert, bst.delete,
bm_start, bm_length, bm_interval)
# Print for comparison.
print("MixedSIDBenchmarkPlot test:")
print("\t operations: " + str(ops))
print("\tPlease hand-check that the following match:")
print("\t\t" + str(expected))
print("\t\t" + str(sim_plot.coordinates))
print("\tReal benchmark's output:")
print("\t\t" + str(real_plot.coordinates))
def worstCaseSID():
"""Performs a full search, insert, and delete benchmark set on all data structures using the worst-case inputs
for binary search trees."""
# Custom test parameters, because a million items will just take eons.
stop = 10000
bm_start = 500
bm_length = 100
bm_interval = 500
# Worst-case insert: all increasing.
insert_samples = list(range(stop))
# Worst-case delete: always the leaf in our worst-case structure.
delete_samples = insert_samples[:]
delete_samples.reverse()
# Worst-case search: search for the last bm_length elements in our worst-case structure. But this is harder
# to create since it only does a search at our various intervals.
search_samples = []
current = bm_start
while current < stop:
search_samples += list(range(current - bm_length, current))
current = min(stop, current + bm_interval)
# Initialize data structures
bst = BinarySearchTree()
stromberg_treap = StrombergTreap()
jenks_treap = JenksTreap()
pyskiplist = PySkipList()
redblacktree = RedBlackTree()
# avltree = AVLTree()
# Final setup, and invocation.
base_filename = "plots/worstCase.tex"
search_filename = base_filename[0:-4] + "_search" + base_filename[-4:]
insert_filename = base_filename[0:-4] + "_insert" + base_filename[-4:]
delete_filename = base_filename[0:-4] + "_delete" + base_filename[-4:]
searches = \
[
bst.search,
stromberg_treap.get_key,
jenks_treap.__getitem__,
pyskiplist.search,
redblacktree.find_node
]
inserts = \
[
bst.insert,
stromberg_treap.insert,
jenks_treap.insert,
pyskiplist.insert,
redblacktree.add
]
deletes = \
[
bst.delete,
stromberg_treap.remove,
jenks_treap.__delitem__,
pyskiplist.remove,
redblacktree.remove
]
title = "Worst-Case Input"
graphSID(search_filename,
insert_filename,
delete_filename,
searches,
inserts,
deletes,
search_samples,
insert_samples,
delete_samples,
stop,
bm_start,
bm_length,
bm_interval,
title=title)
def min_height_binary_search_tree(sorted_integers):
bst = BinarySearchTree()
root = insert_middle(bst, sorted_integers, 0, len(sorted_integers))
bst.insert(root)
return bst
def test_basic_checks(self):
bst = BinarySearchTree()
# Root node: 7
bst.insert(7)
self.assertEqual(7, bst.root.key, "Insert key as root")
# 7
# /
# 3
bst.insert(3)
self.assertEqual(3, bst.root.left.key, "Insert key as root's left child")
# 7
# / \
# 3 11
bst.insert(11)
self.assertEqual(11, bst.root.right.key, "Insert key as root's right child")
# 7
# / \
# 3 11
# /
# 1
bst.insert(1)
self.assertEqual(1, bst.root.left.left.key, "Insert key as left child of non-root node")
# 7
# / \
# 3 11
# / \
# 1 13
bst.insert(13)
self.assertEqual(13, bst.root.right.right.key, "Insert key as right child of non-root node")
# 7
# / \
# 3 11
# / / \
# 1 9 13
bst.insert(9)
self.assertEqual(9, bst.root.right.left.key, "Insert key as left child of right child")
# 7
# / \
# 3 11
# / \ / \
# 1 5 9 13
bst.insert(5)
self.assertEqual(5, bst.root.left.right.key, "Insert key as right child of left child")
for i in range(1, 14, 2):
self.assertEqual(i, bst.search(i), "Search full tree for {}.".format(i))
for i in range(0, 15, 2):
self.assertIsNone(bst.search(i), "Search full tree for nonexistent items.")
# By adding a few more elements, we can test all basic deletion cases with a bit of planning.
# (Some corner cases may not be covered, e.g. testing whether a replacement works with both None and Node)
# 7
# / \
# 3 11
# / \ / \
# 1 5 9 13
# / /
# 8 12
bst.insert(8)
bst.insert(12)
# Possible deletion cases:
# A - delete root with successor as leftmost child of right subtree (IOS)
# B - delete root with left and right children, right has no left subtree
# C - delete root with only right child
# D - delete root with only left child
# E - delete root with no children, leaving an empty tree
# F - delete non-root node with successor as leftmost child of right subtree (IOS)
# G - delete non-root node with only right child
# H - delete non-root node with only left child
# I - delete non-root node with left and right children, right child is a leaf
# J - delete non-root leaf
# Deletions, in order, matched with cases above:
# 7 - A
# 3 - I
# 11 - F
# 9 - J
# 5 - H
# 12 - G
# 8 - B
# 13 - D
# This leaves a tree with one node, 1.
# Then we'll insert 2 to form the tree
# 1
# \
# 2
# And we'll delete:
# 1 - C
# 2 - E
for i in [7, 3, 11, 9, 5, 12, 8, 13]:
self.assertTrue(bst.delete(i), "Test deletion cases")
self.assertIsNone(bst.search(i), "Search for deleted item")
bst.insert(2)
for i in [1, 2]:
self.assertTrue(bst.delete(i), "Test deletion cases")
self.assertIsNone(bst.search(i), "Search for deleted item")
self.assertFalse(bst.delete(6), "Delete item that's not in the tree")
self.assertFalse(bst.delete(7), "Delete item previously removed from tree")
self.assertIsNone(bst.search(1), "Search empty tree")