コード例 #1
0
ファイル: ACME_LAB5v2.py プロジェクト: rmcarthur/acme_labs
def test2():
    B = BST()
    B.insert(4)
    B.insert(3)
    B.insert(6)
    B.insert(5)
    B.insert(7)
    B.insert(8)
    B.insert(1)
    print B
コード例 #2
0
ファイル: testcases.py プロジェクト: smwade/ACME-1
 def test_2(self):
     A = BST()
     A.insert(4)
     A.insert(3)
     A.insert(6)
     A.insert(5)
     A.insert(7)
     A.insert(8)
     A.insert(1)
コード例 #3
0
ファイル: solutions.py プロジェクト: smwade/ACME-1
    def __init__(self, data_set):
        """Set the k attribute and fill the tree with the points in 'data_set'.

        Raises:
            TypeError: if 'data_set' is not a numpy array (of type np.ndarray)
        """

        # Validate the input type.
        if not isinstance(data_set, np.ndarray):
            raise TypeError("data_set must be a numpy array.")

        # Set the root and dimension attributes.
        BST.__init__(self)
        self.k = data_set.shape[1]

        # Load the data into the tree one point at a time.
        for point in data_set:
            self.insert(point)
コード例 #4
0
ファイル: ACME_LAB5v2.py プロジェクト: rmcarthur/acme_labs
def test3():
    B = BST()
    B.insert(4)
    B.insert(3)
    B.insert(6)
    B.insert(5)
    B.insert(7)
    B.insert(8)
    B.insert(1)
    print B

    B.remove(6)
    print B

    C = BST()
    C.insert(5)
    C.insert(2)
    C.insert(9)
    C.insert(1)
    C.insert(4)
    C.insert(3)
    print C
    C.remove(2)
    print C

    D = BST()
    D.insert(1)
    D.insert(2)
    D.insert(3)
    D.insert(4)
    D.insert(5)
    D.insert(6)
    print D
    D.remove(1)
    print D
コード例 #5
0
ファイル: ACME_LAB5v2.py プロジェクト: rmcarthur/acme_labs
def plot_times(filename="English.txt", start=500, stop=5500, step=500):
    """Vary n from 'start' to 'stop', incrementing by 'step'. At each
    iteration, use the create_word_list() from the 'WordList' module to
    generate a list of n randomized words from the specified file.
    
    Time (separately) how long it takes to load a LinkedList, a BST, and
    an AVL with the data set.
    
    Choose 5 random words from the data set. Time how long it takes to
    find each word in each object. Calculate the average search time for
    each object.
    
    Create one plot with two subplots. In the first subplot, plot the
    number of words in each dataset against the build time for each object.
    In the second subplot, plot the number of words against the search time
    for each object.
    
    Inputs:
        filename (str): the file to use in creating the data sets.
        start (int): the lower bound on the sample interval.
        stop (int): the upper bound on the sample interval.
        step (int): the space between points in the sample interval.
    
    Returns:
        Show the plot, but do not return any values.
    """
    interval = (stop-start)/step
    n_list = np.linspace(start,stop,interval+1)
    n_list = np.int16(n_list)
    

    word_list = create_word_list(filename)
    
    load_list = []
    load_BST = []
    load_AVL = []
    
    find_list = []
    find_BST = []
    find_AVL = []
    
    for n in n_list:
        temp_word_list = word_list[:n]
        random_word_indices = np.random.randint(0,n,size=5)
        words_to_find = []
        for x in random_word_indices:
            words_to_find.append(temp_word_list[x])

        L = LinkedList()
        B = BST()
        A = AVL()
        
        start = time()
        for word in temp_word_list:
            L.add(word)
        end = time()
        load_list.append(end-start)

        start = time()
        for word in temp_word_list:
            B.insert(word)
        end = time()
        load_BST.append(end-start)

        start = time()
        for word in temp_word_list:
            A.insert(word)
        end = time()
        load_AVL.append(end-start)
        
        start = time()
        for word in words_to_find:
            iterative_search(L, word)
        end = time()
        find_list.append(end-start)

        start = time()
        for word in words_to_find:
            B.find(word)
        end = time()
        find_BST.append(end-start)

        start = time()
        for word in words_to_find:
            A.find(word)
        end = time()
        find_AVL.append(end-start)
    
    avg_find_list = sum(find_list[:])/5.
    avg_find_BST = sum(find_BST[:])/5.
    avg_find_AVL = sum(find_AVL[:])/5.

    plt.subplot(121)
    list_plot1 = plt.plot(n_list, load_list,label='Singly-Linked List')
    BST_plot1 = plt.plot(n_list, load_BST, label='Binary Search Tree')
    AVL_plot1 = plt.plot(n_list, load_AVL, label='AVL Tree')
    plt.legend()
    plt.xlabel('Data Points')
    plt.ylabel('Seconds')
    plt.title('Build Times')

    plt.subplot(122)
    list_plot2 = plt.plot(n_list, find_list,label='Singly-Linked List')
    BST_plot2 = plt.plot(n_list, find_BST, label='Binary Search Tree')
    AVL_plot2 = plt.plot(n_list, find_AVL, label='AVL Tree')
    plt.legend()
    plt.xlabel('Data Points')
    plt.ylabel('Seconds')
    plt.title('Search Times')

    plt.show() 
コード例 #6
0
ファイル: solutions.py プロジェクト: smwade/ACME-1
def plot_times(filename="English.txt", start=500, stop=5500, step=500):
    """Vary n from 'start' to 'stop', incrementing by 'step'. At each
    iteration, use the create_word_list() from the 'WordList' module to
    generate a list of n randomized words from the specified file.
    
    Time (separately) how long it takes to load a LinkedList, a BST, and
    an AVL with the data set.
    
    Choose 5 random words from the data set. Time how long it takes to
    find each word in each object. Calculate the average search time for
    each object.
    
    Create one plot with two subplots. In the first subplot, plot the
    number of words in each dataset against the build time for each object.
    In the second subplot, plot the number of words against the search time
    for each object.
    
    Inputs:
        filename (str): the file to use in creating the data sets.
        start (int): the lower bound on the sample interval.
        stop (int): the upper bound on the sample interval.
        step (int): the space between points in the sample interval.
    
    Returns:
        Show the plot, but do not return any values.
    """

    def wrapper(func, *args, **kwargs):
        def wrapped():
            return func(*args, **kwargs)
        return wrapped

    def add_all(A, my_list):
        for x in my_list:
            A.add(x)

    def add_all_tree(A, my_list):
        for x in my_list:
            A.insert(x)

    def find_it(A, to_find):
        A.find(to_find)

    def find_average(A, my_list):
        find_times = []
        for x in range(5):
            to_find = random.choice(my_list)
            # to_find = my_list[x]
            wrapped = wrapper(find_it, A, to_find)
            find_times.append(timeit.timeit(wrapped, number=1))
        return np.mean(find_times)





    word_list = WordList.create_word_list()
    word_list = np.random.permutation(word_list)
    x_values = range(start, stop, step)
    list_times = []
    bst_times = []
    avl_times = []
    find_list= []
    find_bst= []
    find_avl= []
    A = LinkedList()
    B = BST()
    C = AVL()

    for x in x_values:
        wrapped = wrapper(add_all, A, word_list[:int(x)])
        list_times.append(timeit.timeit(wrapped, number=1))
        find_list.append(find_average(A, word_list[:int(x)]))
        A.clear()


    for x in x_values:
        wrapped = wrapper(add_all_tree, B, word_list[:int(x)])
        bst_times.append(timeit.timeit(wrapped, number=1))
        find_bst.append(find_average(B, word_list[:int(x)]))
        B.clear()

    for x in x_values:
        wrapped = wrapper(add_all_tree, C, word_list[:int(x)])
        avl_times.append(timeit.timeit(wrapped, number=1))
        find_avl.append(find_average(C, word_list[:int(x)]))
        C.clear()




    plt.subplot(121)
    plt.plot(x_values, list_times, label='Linked List')
    plt.plot(x_values, bst_times, label='BST')
    plt.plot(x_values, avl_times, label='AVL')
    plt.legend(loc='upper left')
    plt.xlabel('data points')
    plt.ylabel('seconds')

    plt.subplot(122)
    plt.plot(x_values, find_list,label='Linked List')
    plt.plot(x_values, find_bst, label='BST')
    plt.plot(x_values, find_avl, label='AVL')
    plt.legend(loc='upper left')
    plt.xlabel('data points')
    plt.ylabel('seconds')

    plt.show()

    plt.xlabel('data points')
コード例 #7
0
ファイル: solutions.py プロジェクト: smwade/ACME-1
    plt.ylabel('seconds')

    plt.subplot(122)
    plt.plot(x_values, find_list,label='Linked List')
    plt.plot(x_values, find_bst, label='BST')
    plt.plot(x_values, find_avl, label='AVL')
    plt.legend(loc='upper left')
    plt.xlabel('data points')
    plt.ylabel('seconds')

    plt.show()

    plt.xlabel('data points')

if __name__ == "__main__":
    A = BST()
    A.insert(2)
    A.insert(1)
    A.insert(7)
    A.insert(6)
    A.insert(5)
    A.insert(4)
    A.insert(3)
    print A
    A.remove(2)
    print A
    A.remove(3)
    print A


# =============================== END OF FILE =============================== #
コード例 #8
0
def plot_times(filename="English.txt", start=500, stop=5500, step=500):
    """Vary n from 'start' to 'stop', incrementing by 'step'. At each
    iteration, use the create_word_list() from the 'WordList' module to
    generate a list of n randomized words from the specified file.
    
    Time (separately) how long it takes to load a LinkedList, a BST, and
    an AVL with the data set.
    
    Choose 5 random words from the data set. Time how long it takes to
    find each word in each object. Calculate the average search time for
    each object.
    
    Create one plot with two subplots. In the first subplot, plot the
    number of words in each dataset against the build time for each object.
    In the second subplot, plot the number of words against the search time
    for each object.
    
    Inputs:
        filename (str): the file to use in creating the data sets.
        start (int): the lower bound on the sample interval.
        stop (int): the upper bound on the sample interval.
        step (int): the space between points in the sample interval.
    
    Returns:
        Show the plot, but do not return any values.
    """

    def get_average_time_linked_list(to_search, linked_list, times_left, current_time = 0):
        while times_left > 0:
            start = time.time()
            iterative_search(linked_list, to_search[times_left-1])
            end =time.time()
            current_time +=(end-start)
            times_left -=1
        return current_time/len(to_search)

    def get_average_time_BST(to_search, BST_list, times_left, current_time =0):
        while times_left >0:
            start = time.time()
            BST_list.find(to_search[times_left-1])
            end = time.time()
            current_time +=(end-start)
            times_left -= 1 
        return current_time/len(to_search)
    def get_average_time_AVL(to_search, AVL_list, times_left, current_time = 0):
        while times_left > 0:
            start = time.time()
            AVL_list.find(to_search[times_left-1])
            end = time.time()
            current_time +=(end-start)
            times_left -= 1
        return current_time/len(to_search)


    word_list = create_word_list(filename)
    if (stop-start)%step!=0:
        raise ValueError("Your steps won't get you from start to stop")
    current = start
    time_linked_list = []
    time_BST_list = []
    time_AVL_list = []

    time_linked_list_search = []
    time_BST_list_search = []
    time_AVL_list_search = []

    set_size = []

    while current < stop:
        current_linked_list = LinkedList()
        current_BST = BST()
        current_AVL = AVL()
        current_list = word_list[:current]
        to_search = np.random.permutation(current_list)
        start_linked_time = time.time()

        for x in current_list:
            current_linked_list.add(x)
        end_linked_time = time.time()

        start_BST_time = time.time()
        for y in current_list:
            current_BST.insert(y)
        end_BST_time = time.time()

        start_AVL_time = time.time()
        for z in current_list:
            current_AVL.insert(z)
        end_AVL_time = time.time()

        time_linked_list.append(end_linked_time - start_linked_time)
        time_BST_list.append(end_BST_time - start_BST_time)
        time_AVL_list.append(end_AVL_time- start_AVL_time)

        time_linked_list_search.append(get_average_time_linked_list(to_search,current_linked_list, len(to_search)))
        time_BST_list_search.append(get_average_time_BST(to_search,current_BST, len(to_search)))
        time_AVL_list_search.append(get_average_time_AVL(to_search,current_AVL, len(to_search)))

        set_size.append(current)

        current+=step
    plt.subplot(2,1,1)
    plt.title('Building Data Structures')
    plt.plot(set_size,time_linked_list, label = 'Linked List', linewidth = 3)
    plt.plot(set_size, time_BST_list, label = "BST", linewidth = 3)
    plt.plot(set_size, time_AVL_list, label = "AVL", linewidth = 3)
    plt.legend(loc = 2)

    plt.subplot(2,1,2)
    plt.title("Searching Data Structures")
    plt.plot(set_size, time_linked_list_search, label = 'Linked list', linewidth = 3)
    plt.plot(set_size, time_BST_list_search, label = 'BST', linewidth = 3)
    plt.plot(set_size, time_AVL_list_search, label = 'AVL', linewidth = 3)
    plt.legend(loc = 2)
    plt.show()
コード例 #9
0
ファイル: solutions.py プロジェクト: tkchris93/ACME
def timings():
    ll = LinkedList()
    bst = BST()
    avl = AVL()

    ll_add = []
    bst_add = []
    avl_add = []

    ll_search = []
    bst_search = []
    avl_search = []

    for items in range(500,5500,500):
        wordlist = create_word_list(items)
        
        ll = LinkedList()
        before = time.time()
        for i in xrange(items):
            ll.add_node(wordlist[i])
        after = time.time()
        ll_add.append(after - before)
    
        random_indices = np.random.random_integers(0,items,5)
        temp = []
        for i in xrange(len(random_indices)):
            before = time.time()
            iterative_search(ll, wordlist[random_indices[i]]) 
            after = time.time()
            temp.append(after - before)
        ll_search.append(sum(temp)/len(temp))
    
        bst = BST()
        before = time.time()
        for i in xrange(items):
            bst.insert(wordlist[i])
        after = time.time()
        bst_add.append(after - before)

        temp = []
        for i in xrange(len(random_indices)):
            before = time.time()
            bst.find(wordlist[random_indices[i]])
            after = time.time()
            temp.append(after - before)
        bst_search.append(sum(temp)/len(temp))

        avl = AVL()
        before = time.time()
        for i in xrange(items):
            avl.insert(wordlist[i])
        after = time.time()
        avl_add.append(after - before)
        
        temp = []
        for i in xrange(len(random_indices)):
            before = time.time()
            avl.find(wordlist[random_indices[i]])
            after = time.time()
            temp.append(after - before)
        avl_search.append(sum(temp)/len(temp))
    
    plt.subplot(1,2,1)
    plt.plot(ll_add, "r")
    plt.plot(bst_add, "g")
    plt.plot(avl_add, "b")
    plt.subplot(1,2,2)
    plt.plot(ll_search, "r")
    plt.plot(bst_search, "g")
    plt.plot(avl_search, "b")
    plt.show()
    plt.close()
    
    return ll_add, ll_search, bst_add, bst_search, avl_add, avl_search
コード例 #10
0
ファイル: testcases.py プロジェクト: smwade/ACME-1
 def test_3(self):
     A = BST()
     A.insert(3)
     A.insert(2)
     A.insert(1)
     A.insert(8)
     A.insert(9)
     A.insert(5)
     A.insert(6)
     print A
     A.remove(8)
     print A
コード例 #11
0
and find the sum pair.
'''

# Import BST defined in Trees.py
from Trees import BST


def findPairSum(target):
    inorder = tree.inOrderTraversal()
    i, j = 0, len(inorder) - 1
    while i < j:
        left, right = inorder[i].data, inorder[j].data
        if left + right == target:
            print(left, right)
            return
        if left + right > target:
            j -= 1
        else:
            i += 1
    print("No such pair found")


inp = [12, 3, 31, -1, 11, -1, 41, -1, -1, -1, -1]
target = 15

# Creating a new BST
tree = BST()
tree.constructBST(inp)

findPairSum(target)
コード例 #12
0
ファイル: solutions.py プロジェクト: tkchris93/ACME
def plot_times(filename="English.txt", start=500, stop=5500, step=500):
    """Vary n from 'start' to 'stop', incrementing by 'step'. At each
    iteration, use the create_word_list() from the 'WordList' module to
    generate a list of n randomized words from the specified file.
    
    Time (separately) how long it takes to load a LinkedList, a BST, and
    an AVL with the data set.
    
    Choose 5 random words from the data set. Time how long it takes to
    find each word in each object. Calculate the average search time for
    each object.
    
    Create one plot with two subplots. In the first subplot, plot the
    number of words in each dataset against the build time for each object.
    In the second subplot, plot the number of words against the search time
    for each object.
    
    Inputs:
        filename (str): the file to use in creating the data sets.
        start (int): the lower bound on the sample interval.
        stop (int): the upper bound on the sample interval.
        step (int): the space between points in the sample interval.
    
    Returns:
        Show the plot, but do not return any values.
    """
    ll = LinkedList()
    bst = BST()
    avl = AVL()

    ll_add = []
    bst_add = []
    avl_add = []

    ll_search = []
    bst_search = []
    avl_search = []

    for items in range(start,stop,step):
        wordlist = create_word_list()[:items]
        
        ll = LinkedList()
        before = time.time()
        for i in xrange(items):
            ll.add(wordlist[i])
        after = time.time()
        ll_add.append(after - before)
    
        random_indices = np.random.random_integers(0,items,5)
        temp = []
        for i in xrange(len(random_indices)):
            before = time.time()
            iterative_search(ll, wordlist[random_indices[i]]) 
            after = time.time()
            temp.append(after - before)
        ll_search.append(sum(temp)/len(temp))
    
        bst = BST()
        before = time.time()
        for i in xrange(items):
            bst.insert(wordlist[i])
        after = time.time()
        bst_add.append(after - before)

        temp = []
        for i in xrange(len(random_indices)):
            before = time.time()
            bst.find(wordlist[random_indices[i]])
            after = time.time()
            temp.append(after - before)
        bst_search.append(sum(temp)/len(temp))

        avl = AVL()
        before = time.time()
        for i in xrange(items):
            avl.insert(wordlist[i])
        after = time.time()
        avl_add.append(after - before)
        
        temp = []
        for i in xrange(len(random_indices)):
            before = time.time()
            avl.find(wordlist[random_indices[i]])
            after = time.time()
            temp.append(after - before)
        avl_search.append(sum(temp)/len(temp))
    
    plt.subplot(1,2,1)
    plt.title("Build Times")
    plt.plot(ll_add, "b", label="Single-Linked List")
    plt.plot(bst_add, "g", label="Binary Search Tree")
    plt.plot(avl_add, "r", label ="AVL Tree")
    plt.legend(loc="upper left")
    plt.subplot(1,2,2)
    plt.title("Search Times")
    plt.plot(ll_search, "b", label="Single-Linked List")
    plt.plot(bst_search, "g", label="Binary Search Tree")
    plt.plot(avl_search, "r", label="AVL Tree")
    plt.legend(loc="upper left")
    plt.show()
    plt.close()
    
    return ll_add, ll_search, bst_add, bst_search, avl_add, avl_search