Space and Time Complexity

Space complexity refers to the amount of memory used by an algorithm to complete its execution, as a function of the size of the input. The space complexity of an algorithm can be affected by various factors such as the size of the input data, the data structures used in the algorithm, the number and size of temporary variables, and the recursion depth. Time complexity refers to the amount of time required by an algorithm to run as the input size grows. It is usually measured in terms of the "Big O" notation, which describes the upper bound of an algorithm's time complexity.

Why do you think a programmer should care about space and time complexity?

  • We should care about space and time complexity because we can make sure the user's input meets the requirements of the function to ensure ideal functionality.

Take a look at our lassen volcano example from the data compression tech talk. The first code block is the original image. In the second code block, change the baseWidth to rescale the image.

from IPython.display import Image, display
from pathlib import Path 

# prepares a series of images
def image_data(path=Path("images/"), images=None):  # path of static images is defaulted
    for image in images:
        # File to open
        image['filename'] = path / image['file']  # file with path
    return images

def image_display(images):
    for image in images:  
        display(Image(filename=image['filename']))

if __name__ == "__main__":
    lassen_volcano = image_data(images=[{'source': "Peter Carolin", 'label': "Lassen Volcano", 'file': "lassen-volcano.jpg"}])
    image_display(lassen_volcano)
    
from IPython.display import HTML, display
from pathlib import Path 
from PIL import Image as pilImage 
from io import BytesIO
import base64

# prepares a series of images
def image_data(path=Path("images/"), images=None):  # path of static images is defaulted
    for image in images:
        # File to open
        image['filename'] = path / image['file']  # file with path
    return images

def scale_image(img):
    baseWidth = 625
    #baseWidth = 1250
    #baseWidth = 2500
    #baseWidth = 5000 # see the effect of doubling or halfing the baseWidth 
    #baseWidth = 10000 
    #baseWidth = 20000
    #baseWidth = 40000
    scalePercent = (baseWidth/float(img.size[0]))
    scaleHeight = int((float(img.size[1])*float(scalePercent)))
    scale = (baseWidth, scaleHeight)
    return img.resize(scale)

def image_to_base64(img, format):
    with BytesIO() as buffer:
        img.save(buffer, format)
        return base64.b64encode(buffer.getvalue()).decode()
    
def image_management(image):  # path of static images is defaulted        
    # Image open return PIL image object
    img = pilImage.open(image['filename'])
    
    # Python Image Library operations
    image['format'] = img.format
    image['mode'] = img.mode
    image['size'] = img.size
    image['width'], image['height'] = img.size
    image['pixels'] = image['width'] * image['height']
    # Scale the Image
    img = scale_image(img)
    image['pil'] = img
    image['scaled_size'] = img.size
    image['scaled_width'], image['scaled_height'] = img.size
    image['scaled_pixels'] = image['scaled_width'] * image['scaled_height']
    # Scaled HTML
    image['html'] = '<img src="data:image/png;base64,%s">' % image_to_base64(image['pil'], image['format'])


if __name__ == "__main__":
    # Use numpy to concatenate two arrays
    images = image_data(images = [{'source': "Peter Carolin", 'label': "Lassen Volcano", 'file': "lassen-volcano.jpg"}])
    
    # Display meta data, scaled view, and grey scale for each image
    for image in images:
        image_management(image)
        print("---- meta data -----")
        print(image['label'])
        print(image['source'])
        print(image['format'])
        print(image['mode'])
        print("Original size: ", image['size'], " pixels: ", f"{image['pixels']:,}")
        print("Scaled size: ", image['scaled_size'], " pixels: ", f"{image['scaled_pixels']:,}")
        
        print("-- original image --")
        display(HTML(image['html'])) 
---- meta data -----
Lassen Volcano
Peter Carolin
JPEG
RGB
Original size:  (2792, 2094)  pixels:  5,846,448
Scaled size:  (625, 468)  pixels:  292,500
-- original image --

Do you think this is a time complexity or space complexity or both problem?

  • It's both... It's a space complexity because when the image is 40000 pixels, the image doesn't render because it is too big. At the same time, it's also a time complexity when the image is bigger, it takes longer for the computer to process it, and if the code is running for too long, it can crash your computer.

Big O Notation

  • Constant O(1)
  • Linear O(n)
  • Quadratic O(n^2)
  • Logarithmic O(logn)
  • Exponential (O(2^n))
numbers = list(range(1000))
print(numbers)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999]

Constant O(1)

Time

An example of a constant time algorithm is accessing a specific element in an array. It does not matter how large the array is, accessing an element in the array takes the same amount of time. Therefore, the time complexity of this operation is constant, denoted by O(1).

print(numbers[263])

ncaa_bb_ranks = {1:"Alabama",2:"Houston", 3:"Purdue", 4:"Kansas"}
#look up a value in a dictionary given a key
print(ncaa_bb_ranks[1]) 
263
Alabama

Space

This function takes two number inputs and returns their sum. The function does not create any additional data structures or variables that are dependent on the input size, so its space complexity is constant, or O(1). Regardless of how large the input numbers are, the function will always require the same amount of memory to execute.

def sum(a, b): 
  return a + b

print(sum(90,88))
print(sum(.9,.88))
178
1.78

Linear O(n)

Time

An example of a linear time algorithm is traversing a list or an array. When the size of the list or array increases, the time taken to traverse it also increases linearly with the size. Hence, the time complexity of this operation is O(n), where n is the size of the list or array being traversed.

for i in numbers:
    print(i)

Space

This function takes a list of elements arr as input and returns a new list with the elements in reverse order. The function creates a new list reversed_arr of the same size as arr to store the reversed elements. The size of reversed_arr depends on the size of the input arr, so the space complexity of this function is O(n). As the input size increases, the amount of memory required to execute the function also increases linearly.

def reverse_list(arr):
    n = len(arr) 
    reversed_arr = [None] * n #create a list of None based on the length or arr
    for i in range(n):
        reversed_arr[n-i-1] = arr[i] #stores the value at the index of arr to the value at the index of reversed_arr starting at the beginning for arr and end for reversed_arr 
    return reversed_arr


print(reverse_list(numbers))

Quadratic O(n^2)

Time

An example of a quadratic time algorithm is nested loops. When there are two nested loops that both iterate over the same collection, the time taken to complete the algorithm grows quadratically with the size of the collection. Hence, the time complexity of this operation is O(n^2), where n is the size of the collection being iterated over.

for i in numbers:
    for j in numbers:
        print(i,j)

Space

This function takes two matrices matrix1 and matrix2 as input and returns their product as a new matrix. The function creates a new matrix result with dimensions m by n to store the product of the input matrices. The size of result depends on the size of the input matrices, so the space complexity of this function is O(n^2). As the size of the input matrices increases, the amount of memory required to execute the function also increases quadratically.

def multiply_matrices(matrix1, matrix2):
    m = len(matrix1) 
    n = len(matrix2[0])
    result = [[0] * n] * m #this creates the new matrix based on the size of matrix 1 and 2
    for i in range(m):
        for j in range(n):
            for k in range(len(matrix2)):
                result[i][j] += matrix1[i][k] * matrix2[k][j]
    return result

print(multiply_matrices([[1,2],[3,4]], [[3,4],[1,2]]))
[[18, 28], [18, 28]]

Logarithmic O(logn)

Time

An example of a log time algorithm is binary search. Binary search is an algorithm that searches for a specific element in a sorted list by repeatedly dividing the search interval in half. As a result, the time taken to complete the search grows logarithmically with the size of the list. Hence, the time complexity of this operation is O(log n), where n is the size of the list being searched.

def binary_search(arr, low, high, target):
    while low <= high:
        mid = (low + high) // 2 #integer division
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1

target = 263
result = binary_search(numbers, 0, len(numbers) - 1, target)

print(result)
263

Space

The same algorithm above has a O(logn) space complexity. The function takes an array arr, its lower and upper bounds low and high, and a target value target. The function searches for target within the bounds of arr by recursively dividing the search space in half until the target is found or the search space is empty. The function does not create any new data structures that depend on the size of arr. Instead, the function uses the call stack to keep track of the recursive calls. Since the maximum depth of the recursive calls is O(logn), where n is the size of arr, the space complexity of this function is O(logn). As the size of arr increases, the amount of memory required to execute the function grows logarithmically.

Exponential O(2^n)

Time

An example of an O(2^n) algorithm is the recursive implementation of the Fibonacci sequence. The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding ones, starting from 0 and 1. The recursive implementation of the Fibonacci sequence calculates each number by recursively calling itself with the two preceding numbers until it reaches the base case (i.e., the first or second number in the sequence). The algorithm takes O(2^n) time in the worst case because it has to calculate each number in the sequence by making two recursive calls.

def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

#print(fibonacci(5))
#print(fibonacci(10))
#print(fibonacci(20))
# print(fibonacci(30))
print(fibonacci(40))
102334155

Space

This function takes a set s as input and generates all possible subsets of s. The function does this by recursively generating the subsets of the set without the first element, and then adding the first element to each of those subsets to generate the subsets that include the first element. The function creates a new list for each recursive call that stores the subsets, and each element in the list is a new list that represents a subset. The number of subsets that can be generated from a set of size n is 2^n, so the space complexity of this function is O(2^n). As the size of the input set increases, the amount of memory required to execute the function grows exponentially.

def generate_subsets(s):
    if not s:
        return [[]]
    subsets = generate_subsets(s[1:])
    return [[s[0]] + subset for subset in subsets] + subsets

# print(generate_subsets([1,2,3]))
print(generate_subsets([1,2,3,4,5,6,7,8]))
# print(generate_subsets(numbers))
[[1, 2, 3, 4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5, 6, 8], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 7, 8], [1, 2, 3, 4, 5, 7], [1, 2, 3, 4, 5, 8], [1, 2, 3, 4, 5], [1, 2, 3, 4, 6, 7, 8], [1, 2, 3, 4, 6, 7], [1, 2, 3, 4, 6, 8], [1, 2, 3, 4, 6], [1, 2, 3, 4, 7, 8], [1, 2, 3, 4, 7], [1, 2, 3, 4, 8], [1, 2, 3, 4], [1, 2, 3, 5, 6, 7, 8], [1, 2, 3, 5, 6, 7], [1, 2, 3, 5, 6, 8], [1, 2, 3, 5, 6], [1, 2, 3, 5, 7, 8], [1, 2, 3, 5, 7], [1, 2, 3, 5, 8], [1, 2, 3, 5], [1, 2, 3, 6, 7, 8], [1, 2, 3, 6, 7], [1, 2, 3, 6, 8], [1, 2, 3, 6], [1, 2, 3, 7, 8], [1, 2, 3, 7], [1, 2, 3, 8], [1, 2, 3], [1, 2, 4, 5, 6, 7, 8], [1, 2, 4, 5, 6, 7], [1, 2, 4, 5, 6, 8], [1, 2, 4, 5, 6], [1, 2, 4, 5, 7, 8], [1, 2, 4, 5, 7], [1, 2, 4, 5, 8], [1, 2, 4, 5], [1, 2, 4, 6, 7, 8], [1, 2, 4, 6, 7], [1, 2, 4, 6, 8], [1, 2, 4, 6], [1, 2, 4, 7, 8], [1, 2, 4, 7], [1, 2, 4, 8], [1, 2, 4], [1, 2, 5, 6, 7, 8], [1, 2, 5, 6, 7], [1, 2, 5, 6, 8], [1, 2, 5, 6], [1, 2, 5, 7, 8], [1, 2, 5, 7], [1, 2, 5, 8], [1, 2, 5], [1, 2, 6, 7, 8], [1, 2, 6, 7], [1, 2, 6, 8], [1, 2, 6], [1, 2, 7, 8], [1, 2, 7], [1, 2, 8], [1, 2], [1, 3, 4, 5, 6, 7, 8], [1, 3, 4, 5, 6, 7], [1, 3, 4, 5, 6, 8], [1, 3, 4, 5, 6], [1, 3, 4, 5, 7, 8], [1, 3, 4, 5, 7], [1, 3, 4, 5, 8], [1, 3, 4, 5], [1, 3, 4, 6, 7, 8], [1, 3, 4, 6, 7], [1, 3, 4, 6, 8], [1, 3, 4, 6], [1, 3, 4, 7, 8], [1, 3, 4, 7], [1, 3, 4, 8], [1, 3, 4], [1, 3, 5, 6, 7, 8], [1, 3, 5, 6, 7], [1, 3, 5, 6, 8], [1, 3, 5, 6], [1, 3, 5, 7, 8], [1, 3, 5, 7], [1, 3, 5, 8], [1, 3, 5], [1, 3, 6, 7, 8], [1, 3, 6, 7], [1, 3, 6, 8], [1, 3, 6], [1, 3, 7, 8], [1, 3, 7], [1, 3, 8], [1, 3], [1, 4, 5, 6, 7, 8], [1, 4, 5, 6, 7], [1, 4, 5, 6, 8], [1, 4, 5, 6], [1, 4, 5, 7, 8], [1, 4, 5, 7], [1, 4, 5, 8], [1, 4, 5], [1, 4, 6, 7, 8], [1, 4, 6, 7], [1, 4, 6, 8], [1, 4, 6], [1, 4, 7, 8], [1, 4, 7], [1, 4, 8], [1, 4], [1, 5, 6, 7, 8], [1, 5, 6, 7], [1, 5, 6, 8], [1, 5, 6], [1, 5, 7, 8], [1, 5, 7], [1, 5, 8], [1, 5], [1, 6, 7, 8], [1, 6, 7], [1, 6, 8], [1, 6], [1, 7, 8], [1, 7], [1, 8], [1], [2, 3, 4, 5, 6, 7, 8], [2, 3, 4, 5, 6, 7], [2, 3, 4, 5, 6, 8], [2, 3, 4, 5, 6], [2, 3, 4, 5, 7, 8], [2, 3, 4, 5, 7], [2, 3, 4, 5, 8], [2, 3, 4, 5], [2, 3, 4, 6, 7, 8], [2, 3, 4, 6, 7], [2, 3, 4, 6, 8], [2, 3, 4, 6], [2, 3, 4, 7, 8], [2, 3, 4, 7], [2, 3, 4, 8], [2, 3, 4], [2, 3, 5, 6, 7, 8], [2, 3, 5, 6, 7], [2, 3, 5, 6, 8], [2, 3, 5, 6], [2, 3, 5, 7, 8], [2, 3, 5, 7], [2, 3, 5, 8], [2, 3, 5], [2, 3, 6, 7, 8], [2, 3, 6, 7], [2, 3, 6, 8], [2, 3, 6], [2, 3, 7, 8], [2, 3, 7], [2, 3, 8], [2, 3], [2, 4, 5, 6, 7, 8], [2, 4, 5, 6, 7], [2, 4, 5, 6, 8], [2, 4, 5, 6], [2, 4, 5, 7, 8], [2, 4, 5, 7], [2, 4, 5, 8], [2, 4, 5], [2, 4, 6, 7, 8], [2, 4, 6, 7], [2, 4, 6, 8], [2, 4, 6], [2, 4, 7, 8], [2, 4, 7], [2, 4, 8], [2, 4], [2, 5, 6, 7, 8], [2, 5, 6, 7], [2, 5, 6, 8], [2, 5, 6], [2, 5, 7, 8], [2, 5, 7], [2, 5, 8], [2, 5], [2, 6, 7, 8], [2, 6, 7], [2, 6, 8], [2, 6], [2, 7, 8], [2, 7], [2, 8], [2], [3, 4, 5, 6, 7, 8], [3, 4, 5, 6, 7], [3, 4, 5, 6, 8], [3, 4, 5, 6], [3, 4, 5, 7, 8], [3, 4, 5, 7], [3, 4, 5, 8], [3, 4, 5], [3, 4, 6, 7, 8], [3, 4, 6, 7], [3, 4, 6, 8], [3, 4, 6], [3, 4, 7, 8], [3, 4, 7], [3, 4, 8], [3, 4], [3, 5, 6, 7, 8], [3, 5, 6, 7], [3, 5, 6, 8], [3, 5, 6], [3, 5, 7, 8], [3, 5, 7], [3, 5, 8], [3, 5], [3, 6, 7, 8], [3, 6, 7], [3, 6, 8], [3, 6], [3, 7, 8], [3, 7], [3, 8], [3], [4, 5, 6, 7, 8], [4, 5, 6, 7], [4, 5, 6, 8], [4, 5, 6], [4, 5, 7, 8], [4, 5, 7], [4, 5, 8], [4, 5], [4, 6, 7, 8], [4, 6, 7], [4, 6, 8], [4, 6], [4, 7, 8], [4, 7], [4, 8], [4], [5, 6, 7, 8], [5, 6, 7], [5, 6, 8], [5, 6], [5, 7, 8], [5, 7], [5, 8], [5], [6, 7, 8], [6, 7], [6, 8], [6], [7, 8], [7], [8], []]

Using the time library, we are able to see the difference in time it takes to calculate the fibonacci function above.

  • Based on what is known about the other time complexities, hypothesize the resulting elapsed time if the function is replaced.
import time

start_time = time.time()
print(fibonacci(34))
end_time = time.time()

total_time = end_time - start_time
print("Time taken:", total_time, "seconds")

start_time = time.time()
print(fibonacci(35))
end_time = time.time()

total_time = end_time - start_time
print("Time taken:", total_time, "seconds")
5702887
Time taken: 2.4168901443481445 seconds
9227465
Time taken: 3.93662691116333 seconds

Hacks

  • Record your findings when testing the time elapsed of the different algorithms.

Constant Time (O(1)) - These algorithms have a constant running time regardless of the size of the input. Logarithmic Time (O(log n)) - Algorithms with logarithmic time complexity have their running time increase logarithmically with the size of the input. Linear Time (O(n)) - These algorithms have their running time proportional to the size of the input. Quadratic Time (O(n^2)) - Algorithms with quadratic time complexity have their running time proportional to the square of the input size. Exponential Time (O(2^n)) - Algorithms with exponential time complexity have their running time increase exponentially with the input size.

  • Although we will go more in depth later, time complexity is a key concept that relates to the different sorting algorithms. Do some basic research on the different types of sorting algorithms and their time complexity.
  • Why is time and space complexity important when choosing an algorithm?

Time and space complexity are important factors to consider when choosing an algorithm because they directly impact the efficiency of an algorithm in terms of how fast it can solve a problem and how much memory it requires to do so.

  • Should you always use a constant time algorithm / Should you never use an exponential time algorithm? Explain?

The decision to use a constant time algorithm or an exponential time algorithm depends on the specific problem being solved and the limitations of the system. While constant time algorithms generally provide the best performance, some problems require algorithms with higher time complexity. In such cases, a trade-off between time and space complexity must be made to find an algorithm that balances both factors according to the system constraints.

Complete the Time and Space Complexity analysis questions linked below. Practice