def create_chain_bst(n): curr = 1 mytree = BinarySearchTree() while curr <= n: #For q1, h = n mytree.insert(curr) #insert runtine is O(h) curr += 1 return mytree
def test_is_bst(self): node1 = b.Node(1) node2 = b.Node(2) node3 = b.Node(3) node4 = b.Node(4) node5 = b.Node(5) # not a bst node1.left = node2 node1.right = node4 node4.left = node3 node4.right = node5 self.class_under_test.root = node1 self.assertFalse(b.is_bst(self.class_under_test)) # is a bst node1 = b.Node(1) node2 = b.Node(2) node3 = b.Node(3) node4 = b.Node(4) node5 = b.Node(5) node2.left = node1 node2.right = node4 node4.left = node3 node4.right = node5 self.class_under_test.root = node2 self.assertTrue(b.is_bst(self.class_under_test))
def setUp(self): # The testing tree should look like this: # 30s # / \ # / \ # / \ # 10 43 # / \ / \ # 21 34 45 # / \ / \ / \ # 15 40 46 # # All nodes should have a count == 1 # except for 46 with count == 4 self.empty_tree = bst.BinarySearchTree() self.tree = bst.BinarySearchTree() self.tree.insert(30) self.tree.insert(43) self.tree.insert(10) self.tree.insert(34) self.tree.insert(21) self.tree.insert(40) self.tree.insert(15) self.tree.insert(45) self.tree.insert(44) self.tree.insert(46) self.tree.insert(46) self.tree.insert(46) self.tree.insert(46)
def testInsert(self): tree = BinarySearchTree([]) tree.insert(0) tree.insert(-5) tree.insert(-2) tree.insert(5) tree.insert(10) self.assertEquals(tree.root.parent, None) self.assertEquals(tree.root.key, 0) leftChild = tree.root.leftChild self.assertEquals(leftChild.parent, tree.root) self.assertEquals(leftChild.key, -5) leftRightChild = leftChild.rightChild self.assertEquals(leftRightChild.parent, leftChild) self.assertEquals(leftRightChild.key, -2) rightChild = tree.root.rightChild self.assertEquals(rightChild.parent, tree.root) self.assertEquals(rightChild.key, 5) rightRightChild = rightChild.rightChild self.assertEquals(rightRightChild.parent, rightChild) self.assertEquals(rightRightChild.key, 10)
def construct(entries): tree = BinarySearchTree() for entry in entries: key, value = entry tree.insert(key, value) return tree
def setUp(self): self.binaryTree = BinarySearchTree() self.binaryTree.addValue(8) self.binaryTree.addValue(3) self.binaryTree.addValue(10) self.binaryTree.addValue(6) self.binaryTree.addValue(1) self.binaryTree.addValue(4) self.binaryTree.addValue(14) self.binaryTree.addValue(7) self.binaryTree.addValue(13)
def immutable_remove_leftmost(self): """ Returns a tree with the leftmost child removed. Search trees are treated as immutable objects in this method. This method is private. """ if self.is_empty: return self elif self.left.is_empty: return self.right else: root = BinarySearchTree(self.key_map, BinaryTree(self.tree.data)) root.left = self.left.immutable_remove_leftmost() root.tree.right = self.tree.right return root
def testSearch(self): tree = BinarySearchTree([0, -5, -2, 5, 10]) self.assertEquals(tree.search(99), None) node = tree.search(-2) self.assertEquals(node.parent.key, -5) self.assertEquals(node.leftChild, None) self.assertEquals(node.rightChild, None) node = tree.search(10) self.assertEquals(node.parent.key, 5) self.assertEquals(node.leftChild, None) self.assertEquals(node.rightChild, None)
def test_post_order_traversal(self): data = ['S', 'E', 'X', 'A', 'R', 'C', 'H', 'M'] tree = BinarySearchTree(TreeNode(data[0])) [tree.insert(TreeNode(i)) for i in data[1:]] expected = ['C', 'A', 'M', 'H', 'R', 'E', 'X', 'S'] self.assertEqual(tree.postOrderTraverse(), expected) self.assertEqual(tree.postOrderTraverseInLoop(), expected) data = ['H', 'C', 'S', 'A', 'E', 'R', 'X'] expected = ['A', 'E', 'C', 'R', 'X', 'S', 'H'] tree = BinarySearchTree(TreeNode(data[0])) [tree.insert(TreeNode(i)) for i in data[1:]] self.assertEqual(tree.postOrderTraverse(), expected) self.assertEqual(tree.postOrderTraverseInLoop(), expected)
def menu_bt(): bt = BinarySearchTree.BinarySearchTree() blist = ArrayList.ArrayList() option = "" while option != '0': print(""" 1 Add to Binary Tree 2 Remove from Binary Tree 3 Display values using BF traversal 4 Display values using in-order 5 Display values using pre-order 6 Display values using post-order 7 Print height of tree 0 Return to main menu """) option = input() if option == "1": bt.add(input("Enter the string index: "),input("Enter the value: ")) elif option == "2": bt.remove(input("Enter index to be removed: ")) elif option == "3": print(bt.bf_traverse()) elif option == "4": print( bt.in_order(bt.r, []) ) elif option == "5": print( bt.pre_order(bt.r, []) ) elif option == "6": print( bt.post_order(bt.r, []) ) elif option == "7": print(bt.height())
def __init_goto_list(self): newstate = 0 def enter(word): assert type(word) == str, "word must be a string" nonlocal newstate state = 0 j = 0 # check if a prefix of word exists tmp = self.goto_list[state].findval(word[j]) while j < len(word) and self.goto_list[state].findval( word[j]) != -1: state = self.goto_list[state].findval(word[j])[1] j = j + 1 # create states for all alphabets, that are not presented in the automata if j < len(word): for p in range(j, len(word)): newstate += 1 self.goto_list[state].insert(word[p], newstate) self.goto_list.append(BinarySearchTree.Node(word[p])) self.output_list.append(None) state = newstate # initialize output function for the inserted word self.output_list[state] = LinkedList.LinkedList(word) self.goto_list.append(BinarySearchTree.Node(chr(0))) self.output_list.append(None) for i in range(len(self.keywords)): enter(self.keywords[i])
def __init__(self): self.bookCatalog = ArrayList.ArrayList() self.shoppingCart = ArrayQueue.ArrayQueue() self.indexKey = ChainedHashTable.ChainedHashTable() self.indexSortedPrefix = BinarySearchTree.BinarySearchTree() self.bookSortedCatalog = ArrayList.ArrayList() self.similaGraph = AdjacencyList.AdjacencyList(0)
def test_remove_root_from_single_node_tree(self): remove_test_tree = bst.BinarySearchTree() remove_test_tree.insert(40) remove_test_tree.remove(40) root = remove_test_tree.get_root() self.assertIsNone(root); self.assertEqual(remove_test_tree.size(), 0)
def test_remove_node_not_in_tree(self): remove_test_tree = bst.BinarySearchTree(); remove_test_tree.insert(20) remove_test_tree.insert(46) remove_test_tree.insert(16) remove_test_tree.remove(17) self.assertEqual(remove_test_tree.size(), 3)
def make_binary_tree(numbers=None): if not numbers: numbers = [5, 2, 7, 1, 3, 6, 8, 0, 9, 4] tree = BinarySearchTree.BinarySearchTree() for i in numbers: tree.insert(i) return tree
def test_to_sorted_doubly_linked_list(self): self.class_under_test.insert(1) self.class_under_test.insert(3) self.class_under_test.insert(4) self.class_under_test.insert(2) result = b.to_sorted_doubly_linked_list(self.class_under_test) self.assertTrue(result.head.data == 1) self.assertTrue(result.head.prev.data == 4)
def test_remove_duplicate_node_in_tree(self): remove_test_tree = bst.BinarySearchTree() remove_test_tree.insert(40) remove_test_tree.insert(46) remove_test_tree.insert(46) remove_test_tree.remove(46) self.assertEqual(remove_test_tree.find(46).count, 1) self.assertEqual(remove_test_tree.size(), 2)
def test_rotate_roots_left_child_to_right(self): self.bst = BinarySearchTree.BinarySearchTree() self.bst.insert(2) self.bst.insert(1) node1 = self.bst.get_node(1) node2 = self.bst.get_node(2) self.bst.rotate(node1) self.assertTrue(self.bst.root == node1 and node1.right == node2)
def test_remove_node_with_no_children(self): remove_test_tree = bst.BinarySearchTree(); remove_test_tree.insert(20) remove_test_tree.insert(46) remove_test_tree.insert(16) remove_test_tree.remove(16) self.assertEqual(remove_test_tree.size(), 2) self.assertIsNone(remove_test_tree.find(16))
def test_prev_order_traversal(self): data = ['S', 'E', 'X', 'A', 'R', 'C', 'H', 'M'] tree = BinarySearchTree(TreeNode(data[0])) [tree.insert(TreeNode(i)) for i in data[1:]] # map returns a iterator in Python3 instead of a list in Python2. # for i in a: # print(i) expected = ['S', 'E', 'A', 'C', 'R', 'H', 'M', 'X'] self.assertEqual(tree.prevOrderTraverse(), expected) self.assertEqual(tree.prevOrderTraverseInLoop(), expected) data = ['H', 'C', 'S', 'A', 'E', 'R', 'X'] expected = ['H', 'C', 'A', 'E', 'S', 'R', 'X'] tree = BinarySearchTree(TreeNode(data[0])) [tree.insert(TreeNode(i)) for i in data[1:]] self.assertEqual(tree.prevOrderTraverse(), expected) self.assertEqual(tree.prevOrderTraverseInLoop(), expected)
def test_remove_node_with_right_child(self): remove_test_tree = bst.BinarySearchTree(); remove_test_tree.insert(20) remove_test_tree.insert(46) remove_test_tree.insert(16) remove_test_tree.insert(17) remove_test_tree.remove(16) self.assertEqual(remove_test_tree.size(), 3) self.assertIsNone(remove_test_tree.find(16)) self.assertEqual(remove_test_tree.find(20).left.value, 17)
def getTopTenPrice(self): print("--------------------------------------------------") print("-----------Top ten assets for price($):-----------") a = BinarySearchTree.DSABinarySearchTree() for i in range(self.vertices.getLength()): a.insert( self.vertices.getNthNode(i).price, self.vertices.getNthNode(i).label) for i in range(10): a.max() print("-----------Top ten assets for price($):-----------")
def getTopTenGain(self): print("------Top ten gainers in the last 7 days(%):------") c = BinarySearchTree.DSABinarySearchTree() for i in range(self.vertices.getLength()): c.insert( self.vertices.getNthNode(i).sevenDay, self.vertices.getNthNode(i).label) for i in range(10): c.max() print("------Top ten gainers in the last 7 days(%):------") print("--------------------------------------------------")
def getTopTenVolume(self): print("--------------------------------------------------") print("----Top ten assets for volume in last 24hr($):----") b = BinarySearchTree.DSABinarySearchTree() for i in range(self.vertices.getLength()): b.insert( self.vertices.getNthNode(i).volume, self.vertices.getNthNode(i).label) for i in range(10): b.max() print("----Top ten assets for volume in last 24hr($):----") print("--------------------------------------------------")
def test_rotate_node_with_only_left_child(self): self.bst = BinarySearchTree.BinarySearchTree() for i in range(3, -1, -1): self.bst.insert(i) nodes = [self.bst.get_node(x) for x in range(4)] self.bst.rotate(nodes[1]) self.assertTrue(nodes[3].left == nodes[1] and nodes[1].parent == nodes[3] and nodes[1].left == nodes[0] and nodes[0].parent == nodes[1] and nodes[1].right == nodes[2] and nodes[2].parent == nodes[1])
def immutable_remove(self, Key): """ Returns a tree where one occurrence of an item with the provided key has been removed. Search trees are treated as immutable objects in this method. This method is private. """ if self.is_empty: return self ownKey = self.key if Key > ownKey: root = BinarySearchTree(self.key_map, BinaryTree(self.tree.data)) root.tree.left = self.tree.left root.right = self.right.immutable_remove(Key) return root elif Key < ownKey: root = BinarySearchTree(self.key_map, BinaryTree(self.tree.data)) root.left = self.left.immutable_remove(Key) root.tree.right = self.tree.right return root elif (not self.left.is_empty) and (not self.right.is_empty): root = BinarySearchTree(self.key_map, BinaryTree(self.right.get_leftmost().tree.data)) root.tree.left = self.tree.left root.right = self.right.immutable_remove_leftmost() return root elif self.left.is_empty: return self.right else: return self.left
def test_get_length_of_a_binary_tree(self): tree = BinarySearchTree(TreeNode(0)) self.assertEqual(len(tree), 1) tree.insert(TreeNode(1)) tree.insert(TreeNode(2)) tree.insert(TreeNode(3)) self.assertEqual(len(tree), 4)
def insert(self, key, value): entry = BST.BSTNode(key, value) if not self.root: self.root = entry x = self.insertOps(entry, self.root) try: print("x key : ", x.key, ", x dad key : ", x.parent.key) except AttributeError: print("root key : ", x.key) while x != self.root: self.splay(x) self.inOrder() return x
def main(): NUMTESTS = 3 test = [False] * NUMTESTS p = None try: p = BinarySearchTree.DSABinarySearchTree() print('\033[92m' "BST successfully created!" '\033[0m') test[0] = True except: print("Failed") try: p.insert("Alex", 5) p.insert("Daniel", 8) p.insert("Geoff", 4) p.insert("Fred", 6) p.insert("George", 9) print('\033[92m' "Data successfully inserted!" '\033[0m') test[1] = True except: print("Failed") try: old_stdout = sys.stdout new_stdout = io.StringIO() sys.stdout = new_stdout p.max() val = new_stdout.getvalue() sys.stdout = old_stdout if val == "9 = George": print("Error") print('\033[92m' "Max successfully found!" '\033[0m') test[2] = True except: print("Failed") count = 0 for i in range(NUMTESTS): if test[i] == True: print("Test", i, "passed!") count += 1 print('\033[93m' "Result for binarySearchTree.py =", (count / NUMTESTS) * 100, "%" '\033[0m')
def create_complete_bst(n): def add_items(bst, low, high): #recursive if low >= ( high + 1 ) // 2: ##insert n number of nodes, and each time you insert, it takes h = log(n) bst.insert(low) ##time because it is a complete bst else: bst = add_items(bst, low * 2, high) now = low times = ((high + 1) // 2) // low for i in range(times): bst.insert(now) now += low * 2 return bst bst = BinarySearchTree() add_items(bst, 1, n) return bst
def test_binarytree(self): points = 0.5 q = BinarySearchTree.BinarySearchTree() try: self.assertIsNone(q.find(2)) self.assertAlmostEqual(q.remove(2), False) except: pass finally: points += 0.5 try: q.add(3, "third") q.add(2, "second") q.add(1, "first") self.assertAlmostEqual(q.size(), 3) self.assertAlmostEqual(q.find(2.5), "third") q.remove(3) self.assertIsNone(q.find(3)) self.assertAlmostEqual(q.size(), 2) q.add(3, "third") q.add(5, "fifth") q.add(4, "fourth") self.assertAlmostEqual(q.size(), 5) self.assertAlmostEqual(q.find(3.4), "fourth") print("In order") q.in_order() print("Pre oder") q.pre_order() print("Pos order") q.pos_order() print("BF Traversal") q.bf_traverse() self.assertAlmostEqual(q.height(), 4) points += 1 except: print("BinarySearchTreeTest is not correct") finally: print(f"BinarySearchTreeTest: {points} Points")
def main(): inputFile = 'Test0.txt' outputFile = 'Test0_output.txt' tree = BinaryTree.BinaryTree(inputFile) bst = BinarySearchTree.BinarySearchTree() # Binary Tree tests with open(outputFile, 'w') as f: f.write(' '.join( str(x) for x in tree.inOrderTraversal(tree.getRoot()))) f.write('\n') tree.clearTraversalResult() f.write(' '.join( str(x) for x in tree.preOrderTraversal(tree.getRoot()))) f.write('\n') tree.clearTraversalResult() f.write(' '.join( str(x) for x in tree.postOrderTraversal(tree.getRoot()))) f.write('\n') tree.clearTraversalResult() print(tree.isBST(tree.getRoot())) # Binary Search Tree tests root = bst.getRoot() root.addKey(random.randint(1, 1000000)) for x in random.sample(range(2, 10000000), 1000000): bst.addNode(root, x) print(bst.isBST(bst.getRoot())) sys.exit()
def test_find_largest_bst(self): node, size = b.find_largest_bst(self.class_under_test) self.assertTrue(node == None) self.assertTrue(size == 0) # whole tree is a bst # 2 <- bst! # 1 4 # 3 5 node1 = b.Node(1) node2 = b.Node(2) node3 = b.Node(3) node4 = b.Node(4) node5 = b.Node(5) node2.left = node1 node2.right = node4 node4.left = node3 node4.right = node5 self.class_under_test.root = node2 node, size = b.find_largest_bst(self.class_under_test) self.assertTrue(node.data == 2) self.assertTrue(size == 5) # part of tree is a bst; there's only one bst # 2 # 1 3 # 6 5 <- bst! # 4 7 # 8 node1 = b.Node(1) node2 = b.Node(2) node3 = b.Node(3) node4 = b.Node(4) node5 = b.Node(5) node6 = b.Node(6) node7 = b.Node(7) node8 = b.Node(8) node2.left = node1 node2.right = node3 node3.left = node6 node3.right = node5 node5.left = node4 node5.right = node7 node7.right = node8 self.class_under_test.root = node2 node, size = b.find_largest_bst(self.class_under_test) self.assertTrue(node.data == 5) self.assertTrue(size == 4) # part of tree is a bst; there's more than one bst # 2 # bst! -> 1 3 # 0 1.5 6 5 <- largest bst! # 4 7 # 8 node0 = b.Node(0) node1 = b.Node(1) node15 = b.Node(1.5) node2 = b.Node(2) node3 = b.Node(3) node4 = b.Node(4) node5 = b.Node(5) node6 = b.Node(6) node7 = b.Node(7) node8 = b.Node(8) node1.left = node0 node1.right = node15 node2.left = node1 node2.right = node3 node3.left = node6 node3.right = node5 node5.left = node4 node5.right = node7 node7.right = node8 self.class_under_test.root = node2 node, size = b.find_largest_bst(self.class_under_test) self.assertTrue(node.data == 5) self.assertTrue(size == 4)
# This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. """ A very simple testing script for the BinarySearchTree class. """ from BinarySearchTree import * import itertools import random t = BinarySearchTree() print t print n = random.randint(5, 15) for _ in itertools.repeat(None, n): x = random.randint(1, 100) print "Adding %d..." % x t.insert(x) print print "Tree of size %d:" % t.getSize() print t print
from BinarySearchTree import * from Node import * from Debugger import * import sys debug = Debugger() debug.disable() debug.printMsg("hello, joel") bst = BinarySearchTree("Joel") bst.insert("34", 34) bst.insert("43", 43) bst.insert("51", 51) bst.insert("12", 12) print "++" * 10 if "43" in bst: print "in here" # print res.data
r: current node ''' def recover_bst_in_order(r): global prev, first, second if r: recover_bst_in_order(r.left) if not prev: prev = r else: if r.data < prev.data: if not first: first = prev # if first is second's direct prior in in-order traversal, second is r # otherwise second will be overwritten later second = r prev = r recover_bst_in_order(r.right) def recover_bst(r): recover_bst_in_order(r) print first,second first.data, second.data = second.data, first.data return r if __name__=='__main__': t=BinarySearchTree() data = [1,2,6,4,5,3,7,8] t.create_tree(data) recover_bst(t.root) t.in_order_print(t.root)
def testInOrderWalk(self): tree = BinarySearchTree([5, 1, 3, 9, -1, -2]) self.assertEquals(tree.inOrderWalk(), [-2, -1, 1, 3, 5, 9])
class Set: """Implementation of the set data structure. A Set here uses a 'BinarySearchTree' as the internal data container. A Set is basically a data container that allows no duplicates in it. @author Thomas Lang @version 1.0, 06/02/2015 """ def __init__(self): """Creates a new Set by instantiating the BinarySearchTree.""" self.tree = BinarySearchTree() def isEmpty(self): """Checks if the Set has no elements in it. @return True if the set is empty, False otherwise. """ return self.tree.isEmpty() def size(self): """Returns the total number of elements contained in the set. @return The size of the set. """ return self.tree.getSize() def union(self, other): """Returns the union of this set and the passed other. The union of two sets describes all elements that are either stored in the first or the second one, or both. @return The union of the two sets. """ if other is None: raise ValueError("Second set must not be null") unionedSet = Set() l = self.__getAll() l += other.__getAll() l.sort() unionedSet.addAll(l) return unionedSet def intersect(self, other): """Returns the intersection of this set and the passed other. The intersection of two sets describes all elements that are both stored in the first and the second one. @return The intersection of the two sets.""" if other is None: raise ValueError("Second set must not be null") intersectedSet = Set() l = other.__getAll() for item in self.__getAll(): if item in l: intersectedSet.add(item) return intersectedSet def difference(self, other): """Returns this set reduced by the passed other set. The difference between two sets A and B describes all elements, that are stored in A but not in B. @return The difference of this set by the passed other.""" if other is None: raise ValueError("Second set must not be null") differenceSet = Set() l = other.__getAll() for item in self.__getAll(): if not item in l: differenceSet.add(item) return differenceSet def __getAll(self): """Returns a list containing all elements in the set.""" return self.tree.getAll() def add(self, value): """Adds the passed value to the set""" return self.tree.add(value) def addAll(self, collection): """Adds all elements from the passed collection to this set.""" if collection is None: raise ValueError("Passed collection must not be null") for item in collection: self.add(item) def contains(self, element): """Checks if the passed element is contained in this set. @return True if the elements is in this set, False otherwise.""" return self.tree.contains(element) def remove(self, element): """Deletes the passed element from this set.""" return self.tree.delete(element) def isSubsetOf(self, other): """Checks if this set is a subset of the passed one. @return True if it is, False otherwise.""" if other is None: raise ValueError("Second set must not be null") l = other.__getAll() isSubset = True for item in self.__getAll(): if not item in l: isSubset = False break return isSubset def hasSubset(self, other): """Checks if the passed set is a subset of this one. @return True if it is, False otherwise.""" if other is None: raise ValueError("Second set must not be null") lall = self.__getAll() hasSubset = True for item in other.__getAll(): if not item in lall: hasSubset = False break return hasSubset def clear(self): """Removes all elements from this set.""" self.tree = BinarySearchTree() def __str__(self): """Returns a String representation of this set.""" if self.isEmpty(): return "(empty set)" return self.tree.__str__()
def __init__(self): """Creates a new Set by instantiating the BinarySearchTree.""" self.tree = BinarySearchTree()
def clear(self): """Removes all elements from this set.""" self.tree = BinarySearchTree()
def InOrderTreeWalk(x): a = [] if x != None: a += InOrderTreeWalk(x.left) a += [x.key] a += InOrderTreeWalk(x.right) return a def TreeSort(A): T = BinarySearchTree() for i in range(0, len(A)): T.insert(A[i]) return InOrderTreeWalk(T.root) if __name__=="__main__": t = BinarySearchTree() print('empty: ' + str(t.isEmpty())) print('size: ' + str(t.size())) t.insert(11) t.insert(6) t.insert(19) t.insert(4) t.insert(8) t.insert(17) t.insert(43) t.insert(5) t.insert(10) t.insert(31) t.insert(49) print('')
def TreeSort(A): T = BinarySearchTree() for i in range(0, len(A)): T.insert(A[i]) return InOrderTreeWalk(T.root)
import BinarySearchTree as BST bst = BST.BinarySeaarchTree() a = """ 1. Insert 2. Search 3. Delete 4. In-order 5. Pre-Order 6. Post-Order 7. Level-Order""" while True: print(a) choice = int(input('Enter your choice: ')) if choice ==1: dat = input('Enter the data you want to insert: ') bst.insert(dat) elif choice == 2: dat = input('Enter the element you want to search: ') if bst.search(dat): print(f'{dat} is in the tree') else: print(f'{dat} is not in the tree') elif choice == 3: dat = input('Enter the element to delete: ') bst.remove(dat) elif choice == 4: print('In-order traversal: ')
def bst_main(): T = create_list_consecutive_numbers(10000) array = get_input("2sumtest1.txt") bst = BST.BinarySearchTree(array) print(sum2_bst(bst, T, array))
def testDelete(self): # Test the no left sub child case tree = BinarySearchTree([1, 2]) tree.delete(tree.root) self.assertEquals(tree.root.key, 2) self.assertEquals(tree.root.leftChild, None) self.assertEquals(tree.root.rightChild, None) # Test the no right sub child case tree = BinarySearchTree([2, 1]) tree.delete(tree.root) self.assertEquals(tree.root.key, 1) self.assertEquals(tree.root.leftChild, None) self.assertEquals(tree.root.rightChild, None) # Test the right sub tree successor is right child case tree = BinarySearchTree([1, 0, 2]) tree.delete(tree.root) self.assertEquals(tree.root.key, 2) self.assertEquals(tree.root.leftChild.key, 0) self.assertEquals(tree.root.rightChild, None) # Test the right sub tree successor is not right child case tree = BinarySearchTree([0, -1, 3, 1]) tree.delete(tree.root) self.assertEquals(tree.root.key, 1) self.assertEquals(tree.root.leftChild.key, -1) self.assertEquals(tree.root.rightChild.key, 3)
closest = current_node.data if value < current_node.data: return findclosestvalueinbsthelper(current_node.left, value, closest) else: return findclosestvalueinbsthelper(current_node.right, value, closest) return closest def findclosestvalueinbst(tree: BinarySearchTree, value: int) -> int: return findclosestvalueinbsthelper(tree.head, value, abs(tree.head.data - value)) if __name__ == "__main__": tree = BinarySearchTree(10) tree.insert(5) tree.insert(15) tree.insert(2) tree.insert(5) tree.insert(13) tree.insert(22) tree.insert(1) tree.insert(14) value = 12 print(findclosestvalueinbst(tree, value))
result.append(root) cnt[0]+=1 midOrder(root.right, k, result, cnt) def kthSmallest(root, k): """ :type root: TreeNode :type k: int :rtype: int """ result = [] midOrder(root, k, result,[1]) return result[0].data if __name__ == '__main__': t=BinarySearchTree() ''' The tree is : 20 / \ 10 40 / \ / \ 3 17 35 73 / \ / \ \ 1 7 15 18 89 \ / / 2 5 11 / \ \ 4 6 12 ''' a=[20,10,40,3,17,35,73,1,7,15,18,89,2,5,11,4,6,12]