Question

(Using C++)

Sample array: 100, 45, 33, 55, 356, 11, 1000, 999, 987

You need to perform the following steps to evaluate the algorithm’s time complexity:

1. Pick any two sorting algorithms (e.g., merge sort, bubble sort).
2. Find the algorithm implementation.
3. Create the array, and store all of the elements described above.
4. Pass the array into the first sorting algorithm.
5. Pass the array into the second sorting algorithm.
6. Calculate the execution time for the first sorting algorithm’s execution.
7. Calculate the execution time for the second sorting algorithm’s execution.

You need to recommend the sorting algorithm that should be used for sorting based on its execution time.

Note that you can use any programming language to implement the steps above.

Your program should contain the following:

• The implementation of the first sorting algorithm
• The implementation of the second sorting algorithm
• An array that can store all of the elements from the sample array

Your program should also do the following:

• Store the start transaction before executing the sorting algorithm, and insert the end transaction afterward
• Calculate the difference between end_transaction and start_transaction
• Pick the sorting algorithm that has the lower execution time

Answer 1

Algorithms :

1. Heap Sort

2. Quick Sort

import timeit

#Heapsort implementation
def heapify(arr, n, i): 
    largest = i 
    l = 2 * i + 1      
    r = 2 * i + 2      
  
    if l < n and arr[i] < arr[l]: 
        largest = l 
  
    if r < n and arr[largest] < arr[r]: 
        largest = r 
  
    if largest != i: 
        arr[i],arr[largest] = arr[largest],arr[i]
  
        heapify(arr, n, largest) 
  
def heapSort(arr): 
    n = len(arr) 
  
    for i in range(n//2 - 1, -1, -1): 
        heapify(arr, n, i) 
  
    for i in range(n-1, 0, -1): 
        arr[i], arr[0] = arr[0], arr[i] 
        heapify(arr, i, 0)
    return arr

#quicksort Implementatio
def partition(arr,low,high): 
    i = ( low-1 )         
    pivot = arr[high] 
  
    for j in range(low , high): 
  
        if   arr[j] < pivot: 
          
            i = i+1 
            arr[i],arr[j] = arr[j],arr[i] 
  
    arr[i+1],arr[high] = arr[high],arr[i+1] 
    return ( i+1 ) 
    
def quickSort(arr,low,high): 
    if low < high: 
  
        pi = partition(arr,low,high)
  
        quickSort(arr, low, pi-1) 
        quickSort(arr, pi+1, high) 
    return arr

data = [100, 45, 33, 55, 356, 11, 1000, 999, 987]

startHeapSort = timeit.timeit()
sortHeap = heapSort(data.copy())
endHeapSort = timeit.timeit()

startQuickSort = timeit.timeit()
sortQuick = quickSort(data.copy(), 0, len(data.copy())-1)
endQuickSort = timeit.timeit()

tHeapSort = endHeapSort - startHeapSort
tQuickSort = endQuickSort - startQuickSort

if tHeapSort < tQuickSort:
    print("Heap Sort execution time is better.")
else:
    print("Quick Sort execution time is better.")