class NodeQ: def __init__(self,val): self.-value = val self.--right = None self.__left None def setLeft(self,n): self.--left = n def setRight(self,n): self.__right - n def getLeft(self): return self.__left def getRight(self): return self.__right def getValue(self): return self.__value class BSTO: def __init__(self); self -root = None def append(self,val): node = Node(val) if self.__rootNone: self.__root node return current-self.__root while True: if vaî <= current.getvalueO: if current.getLeft() == None: current.setLeft(node) return else: current - current.getLeft( else: if current.getRightO None: current.setRight(node) return else: current - current.getRightO def isin(self, val): if self.__rootNone: return False current-self.__root while current-None: if current.getValụe○ == va1: return True elif val < current.getValueC): current - current.getLeft( else: current - current.getRightQ
This code is for python
Searching for Data
In this lab we'll compare the time it takes to search for an item in a list vs searching for it in a binary search tree.
Part 1: Populating and Searching a List
To get started create a function, populate, that takes as a parameter a positive integer n, populates a list of length n with random integers in the range of [0, n] and returns that list.
Next create a function that takes as a parameter a list and an integer and returns True if that integer is found in the list and False if it is not.
Finally, in your main script call your function for a value of n to get a list of length n and then go through that list and look for each element in that list within the list and print out that count. Needless to say if you did everything right you should print out n
Part 2: Populating and Searching a Binary Search Tree
Download the provided BST.py module. This module is a stripped down implementation of a Binary Search Tree and associated Node class.
The BST class has the following public methods:
- Constructor - Creates an empty binary search tree.
- append(value) - Creates a Node with the value value and inserts it into the BST.
- isin(value) - Returns True if value is found in a Node of the BST and False otherwise.
Change your main script so that your populate function creates both a list and a Binary Search Tree with the same random n elements and returns them both. In addition, change your main script so that with in looks for all the values of the list within the list, that it also counts how many times those values exist in the BST and prints that number out as well.
Part 3: Timing
Now let's time how long it takes to look for all n values within both the list and the BST! To do this, first import the time module. The time module has a time() function that returns the system time. Get this value before checking the list for all the values and then again after you're done checking the list. Print out the difference in these times. Now do the same thing for searching the BST!
Part 4: Plot n vs. time
Finally onto the cool stuff! In the previous parts you were asked to just use some arbitrary value of n. Now let's do everything you did in Part 3 but for a range of values of n. In particular let's go from n=1 to n=10,000 in steps of 1000. Keep track of the times for each of these runs for searching both the list and the BST so that you can plot them!As a reminder, we can use the matplotlib library to help us plot. So first import matplotlib.pyplot as plt. If you cannot import this module, then you may need to install (pip) matplotlib.Then you can make use of the following methods:
- plt.plot(xvals,yvals,label='text') - Adds a plot of xvals vs yvals to the current figure with a label saying 'text'. Doing this several times superimposes the plots.
- plt.legend() - This will "enable" the labels to be shown as a legend.
- plt.show() - This displays the figure.
Finally, plot n vs average list search time and n vs average BST search time.
Attached is the BTS.py module
Trending now
This is a popular solution!
Step by step
Solved in 10 steps with 4 images
