def test_valid():
print('{}'.format('-' * 20))
print('Testing BST.valid:\n')
bst = BST()
print('bst = {}'.format(bst.inorder()))
print('bst.valid() = {}'.format(bst.is_valid()))
print()
bst = get_bst()
print('bst = {}'.format(bst.inorder()))
print('bst.valid() = {}'.format(bst.is_valid()))
print()
print('change bst property (change 19 to 29):')
bst._root._left._right._data = 29
print('bst = {}'.format(bst.inorder()))
print('bst.valid() = {}'.format(bst.is_valid()))
print()
print('change bst property (change 38 to 48):')
bst._root._left._right._data = 19
bst._root._right._right._left._data = 48
print('bst = {}'.format(bst.inorder()))
print('bst.valid() = {}'.format(bst.is_valid()))
print()
print('End of BST.valid testing')
print('{}\n'.format('-' * 20))
return
def test_new_tree():
from bst import BST
new_bst = BST()
new_bst.insert(100)
new_bst.insert(25)
new_bst.insert(30)
new_bst.insert(40)
assert [x for x in new_bst.inorder(new_bst.head)] == [25, 30, 40, 100]
def test_inorder():
nums = range(1, 200)
random.shuffle(nums)
bst = BST()
for n in nums:
bst.add(n)
nums.sort()
assert bst.inorder() == sorted(nums)
def test_property2():
print('{}'.format('-' * 20))
print('Testing BST.property2:\n')
bst = BST()
print('bst = {}'.format(bst.inorder()))
print('Satisfy Property 2? = {}'.format(bst.satisfy_property2()))
print()
cases = [25, 13, 11, 19, 35, 20, 40, 33, 18]
for case in cases:
bst.insert(case)
print('bst = {}'.format(bst.inorder()))
print('Satisfy Property 2? = {}'.format(bst.satisfy_property2()))
print()
print('End of BST.property2 testing')
print('{}\n'.format('-' * 20))
return
def test_equal():
print('{}'.format('-' * 20))
print('Testing BST equal operator:\n')
bst1 = BST()
bst2 = BST()
print('bst1 = {}'.format(bst1.inorder()))
print('bst2 = {}'.format(bst2.inorder()))
print('bst1 == bst2? {}'.format(bst1 == bst2))
print()
bst1.insert(25)
bst1.insert(30)
bst2.insert(25)
bst2.insert(30)
bst2.insert(40)
print('bst1 = {}'.format(bst1.inorder()))
print('bst2 = {}'.format(bst2.inorder()))
print('bst1 == bst2? {}'.format(bst1 == bst2))
print()
bst1 = get_bst()
bst2 = get_bst()
print('bst1 = {}'.format(bst1.inorder()))
print('bst2 = {}'.format(bst2.inorder()))
print('bst1 == bst2? {}'.format(bst1 == bst2))
print()
bst2.remove(32)
print('bst1 = {}'.format(bst1.inorder()))
print('bst2 = {}'.format(bst2.inorder()))
print('bst1 == bst2? {}'.format(bst1 == bst2))
print()
bst1.remove(20)
print('bst1 = {}'.format(bst1.inorder()))
print('bst2 = {}'.format(bst2.inorder()))
print('bst1 == bst2? {}'.format(bst1 == bst2))
print()
print('End of BST equality operator testing testing')
print('{}\n'.format('-' * 20))
return
def bstsort(l):
arbol = BST()
# Generamos nuestra estructura
# de datos auxiliar
while l:
# Vaciamos la lista en el arbol
item = l.pop()
arbol.add(item)
l.extend(arbol.inorder())
def test_reflect():
print('{}'.format('-' * 20))
print('Testing BST.reflect_vertical:\n')
print('Note: printing using inorder')
bst = BST()
print('bst1 = {}'.format(bst.inorder()))
bst2 = bst.reflect_vertical()
print('bst2 = {}'.format(bst2.inorder()))
print()
cases = [25, 13, 35, 11, 40, 19, 20, 18]
for case in cases:
bst.insert(case)
print('bst1 = {}'.format(bst.inorder()))
bst2 = bst.reflect_vertical()
print('bst2 = {}'.format(bst2.inorder()))
print()
print('End of BST.reflect vertical testing')
print('{}\n'.format('-' * 20))
return
from bst import BST
if __name__ == '__main__':
t = BST() # 이진탐색트리 객체 t 생성
t.put(500, 'apple')
t.put(600, 'banana')
t.put(200, 'melon')
t.put(100, 'orange')
t.put(400, 'lime')
t.put(250, 'kiwi')
t.put(150, 'grape')
t.put(800, 'peach')
t.put(700, 'cherry')
t.put(50, 'pear')
t.put(350, 'lemon')
t.put(10, 'plum')
print('전위순회:\t', end='')
t.preorder(t.root)
print('\n중위순회:\t', end='')
t.inorder(t.root)
print('\n250: ',t.get(250))
t.delete(200)
print('200 삭제 후:')
print('전위순회:\t', end='')
t.preorder(t.root)
print('\n중위순회:\t', end='')
t.inorder(t.root)
from bst import BST, Node def sorted_array_to_bst(array): return _sorted_array_to_bst(array, 0, len(array)-1) def _sorted_array_to_bst(array, left, right): if left == right: return Node(array[left]) if left > right: return None mid = (left + right) / 2 root = Node(array[mid]) root.left = _sorted_array_to_bst(array, left, mid-1) root.right = _sorted_array_to_bst(array, mid+1, right) return root if __name__ == "__main__": array = [0, 1, 2, 3, 4, 5] tree = BST(sorted_array_to_bst(array)) tree.inorder()
def test_init_empty():
t = BST()
assert t.inorder() == []
def createConcordance(inputFile, stopWords, outputFile):
#declare data structures
stopSet = HashSet(3500)
dictionary = HashDictionary(10000)
bst = BST()
#declare regular expressions
newLine = re.compile(r'\n')
exprSpaces = re.compile(r'\s')
dhyp = re.compile('--')
notChars = re.compile('\W|-')
#populate hashset with stop words
stopWords = open(stopWords, 'r')
for stop in stopWords:
x = newLine.search(stop)
stop = stop[:x.start()]
if stop == "":
break
stopSet.add(stop)
stopWords.close()
#open the input and process into words
f = open(inputFile, 'r')
lineNum = 0
while True:
line = f.readline()
lineNum += 1
if line == "":
break
#split lines
m = dhyp.split(line)
alist = []
for i in range(len(m)):
g = exprSpaces.split(m[i])
alist = alist + g
#strip down to words
print alist
for word in alist:
if word == None:
pass
else:
word = string.lower(word)
while True:
n = notChars.search(word)
if len(word) <= 0:
break
elif n != None:
if n.start() == 0:
word = word[n.end():]
else:
word = word[:n.start()]
else:
break
#check if word is stop word
if not stopSet.contains(word) and len(word) > 0:
#if word isn't already in dictionary
if dictionary.search(word) == None:
linkedValue = LinkedIndexedList()
dictionary.store(word, linkedValue)
dictionary.search(word).append(lineNum)
bst.add(word)
#if the word is in the dictionary
else:
dictionary.search(word).append(lineNum)
f.close()
#open output and use BST to print out words
# in alphabetical order
output = open(outputFile, 'w')
lyst = bst.inorder()
temp = None
for item in lyst:
temp = dictionary.search(item)
output.write(item + " - " + str(temp)+"\n")
output.close()
from bst import BST from bst import Node if __name__ == "__main__": root = Node(5) bst = BST() bst.insert(root, Node(2)) bst.insert(root, Node(3)) bst.insert(root, Node(4)) print "Inorder traversal" bst.inorder(root) print "Preorder traversal" bst.preorder(root) print "Postorder traversal" bst.postorder(root)
class TestBST(unittest.TestCase): def setUp(self): self.bst = BST() def test_insert(self): self.assertEqual([], self.bst.inorder()) self.assertEqual(True, self.bst.insert(5)) self.assertEqual(False, self.bst.insert(5)) self.assertEqual([5], self.bst.inorder()) self.assertEqual(True, self.bst.insert(4)) self.assertEqual([4,5], self.bst.inorder()) self.assertEqual(True, self.bst.insert(7)) self.assertEqual([4,5,7], self.bst.inorder()) def test_find(self): self.assertEqual(False, self.bst.find(5)) self.bst.insert(5) self.assertEqual(True, self.bst.find(5)) self.assertEqual(False, self.bst.find(12)) self.bst.insert(12) self.assertEqual(True, self.bst.find(5)) self.assertEqual(True, self.bst.find(12)) self.bst.remove(12) self.assertEqual(True, self.bst.find(5)) self.assertEqual(False, self.bst.find(12)) self.bst.remove(5) self.assertEqual(False, self.bst.find(5)) def test_remove_1(self): # Empty tree self.assertEqual(False, self.bst.remove(5)) def test_remove_2_1(self): # Value in root # 2.1 Leaf node self.bst.insert(5) self.assertEqual(True, self.bst.remove(5)) self.assertEqual([], self.bst.inorder()) def test_remove_2_2(self): # 2.2 Left chilid only self.bst.insert(5) self.bst.insert(4) self.bst.insert(3) self.assertEqual(5, self.bst.root.data) self.assertEqual([3,4,5], self.bst.inorder()) self.assertEqual(True, self.bst.remove(5)) self.assertEqual([3, 4], self.bst.inorder()) self.assertEqual(4, self.bst.root.data) def test_remove_2_3(self): # 2.3 Right child only self.bst.insert(5) self.bst.insert(7) self.bst.insert(6) self.assertEqual(5, self.bst.root.data) self.assertEqual([5,6,7], self.bst.inorder()) self.assertEqual(True, self.bst.remove(5)) self.assertEqual([6,7], self.bst.inorder()) self.assertEqual(7, self.bst.root.data) def test_remove_2_4(self): # 2.4 Both children self.bst.insert(5) self.bst.insert(4) self.bst.insert(8) self.bst.insert(7) self.bst.insert(6) self.assertEqual(5, self.bst.root.data) self.assertEqual([4,5,6,7,8], self.bst.inorder()) self.assertEqual(True, self.bst.remove(5)) self.assertEqual([4, 6, 7, 8], self.bst.inorder()) self.assertEqual(6, self.bst.root.data) def test_remove_3(self): # Value not in tree self.bst.insert(5) self.bst.insert(4) self.bst.insert(8) self.bst.insert(7) self.bst.insert(6) self.assertEqual(False, self.bst.remove(100)) def test_remove_4(self): # Node is leaf self.bst.insert(5) self.bst.insert(4) self.assertEqual(True, self.bst.remove(4)) self.assertEqual([5], self.bst.inorder()) def test_remove_5(self): # Node has left child only self.bst.insert(5) self.bst.insert(4) self.bst.insert(8) self.bst.insert(7) self.bst.insert(6) self.assertEqual(True, self.bst.remove(8)) self.assertEqual([4,5,6,7], self.bst.inorder()) self.assertEqual(7, self.bst.root.right.data) def test_remove_6(self): # Node has right child only self.bst.insert(5) self.bst.insert(3) self.bst.insert(4) self.assertEqual(True, self.bst.remove(3)) self.assertEqual([4,5], self.bst.inorder()) self.assertEqual(4, self.bst.root.left.data) def test_remove_7(self): # Node has left and right child self.bst.insert(5) self.bst.insert(3) self.bst.insert(4) self.bst.insert(1) self.assertEqual(True, self.bst.remove(3)) self.assertEqual([1,4,5], self.bst.inorder()) self.assertEqual(4, self.bst.root.left.data) def test_preorder(self): self.bst.insert(5) self.bst.insert(4) self.bst.insert(8) self.bst.insert(7) self.bst.insert(6) self.bst.insert(9) self.assertEqual([5,4,8,7,6,9], self.bst.preorder()) def test_postorder(self): self.bst.insert(5) self.bst.insert(4) self.bst.insert(8) self.bst.insert(7) self.bst.insert(6) self.bst.insert(9) self.assertEqual([4,6,7,9,8,5], self.bst.postorder()) def test_inorder(self): self.bst.insert(5) self.bst.insert(4) self.bst.insert(8) self.bst.insert(7) self.bst.insert(6) self.bst.insert(9) self.assertEqual([4,5,6,7,8,9], self.bst.inorder())
def main():
bst = BST()
bst.add(3)
bst.add(7)
bst.add(1)
bst.inorder()
def main():
nums = ["5", "3", "1", "6", "2", "8", "0", "9", "7", "4"]
newBST = BST(list_of_objects = nums)
newBST.inorder()
def test_init_list():
nums = range(0, 10)
t = BST(keys=nums)
assert t.inorder() == nums
def tree_sort(A):
tree = BST()
for i in A:
tree.insert(Node(i))
tree.inorder(tree.root)
def test_unique_queue():
BST(keys=[1])
t = BST(keys=[2])
assert t.inorder() == [2]
