Ejemplo n.º 1
0
 def test_partitionExpectedTransformation2(self):
     array = [4, 5, 1, 0, 8, 4, 3, 7, 6]
     pivotI = 5
     expected = [4, 1, 0, 3, 4, 6, 5, 7, 8]
     qs = QuickSort()
     result = qs.partition(array, pivotI)
     self.assertEqual(expected,result)
Ejemplo n.º 2
0
    def _tempo_do_quick_sort_para_ordernar_a_lista(self, lista) -> float:
        quick_sort = QuickSort()
        start = timeit.default_timer()
        quick_sort.quick_sort(lista, 0, len(lista) - 1)
        end = timeit.default_timer()

        return end - start
Ejemplo n.º 3
0
 def test_partitionWrongPivotIndex(self):
     size = r.randint(5,50)
     array = [r.randint(0,size) for i in xrange(size)]
     pivotIndex = size;
     qs = QuickSort()
     
     result = qs.partition(array, pivotIndex)
     self.assertEqual(array,result)
Ejemplo n.º 4
0
    def sorted_merge_brute(A, B):
        y = 0
        for i in range(len(A)):
            if A[i] is None:
                A[i] = B[y]
                y += 1

        qs = QuickSort()
        qs.quick_sort(A)
        print(A)
Ejemplo n.º 5
0
def test_quicksort_1():
  arr = [1,8,9,3,7,4,6,2,5]

  actual = QuickSort(arr)
  expected = [1,2,3,4,5,6,7,8,9]

  assert actual == expected
Ejemplo n.º 6
0
def test_quicksort_3():
  arr = [79, 457, 39, 74, 20, 74, 29, 68, 270, 1]

  actual = QuickSort(arr)
  expected = [1, 20, 29, 39, 68, 74, 74, 79, 270, 457]

  assert actual == expected
Ejemplo n.º 7
0
def test_quicksort_2():
  arr = [9,8,7,6,5,4,3,2,1]

  actual = QuickSort(arr)
  expected = [1,2,3,4,5,6,7,8,9]

  assert actual == expected
Ejemplo n.º 8
0
 def __init__(self, array: List, value: int):
     a = array[:]
     QuickSort(a)
     self.result_first = self.search_first(a, value)
     self.result_last = self.search_last(a, value)
     self.result_first_greater_equal_to = self.search_first_greater_equal_to(
         a, value)
     self.result_last_smaller_equal_to = self.search_last_smaller_equal_to(
         a, value)
Ejemplo n.º 9
0
    def zero_quadruplets_count(cls, first_seq, second_seq, third_seq, fourth_seq):
        fourth_seq = QuickSort.quick_sort(fourth_seq)
        quadrupletes = []
        for num1 in first_seq:
            for num2 in second_seq:
                for num3 in third_seq:
                    num4 = -(num1 + num2 + num3)

                    if cls.binary_search(fourth_seq, num4) is not None:
                        quadrupletes.append([num1, num2, num3, num4])

        return len(quadrupletes)
Ejemplo n.º 10
0
 def test_exchanger(self):
     qs = QuickSort()
     # A list of len <= 1 should return the list itself
     self.assertEquals(qs.exchanger(10, 10), None)
     self.assertEquals(qs.exchanger(10, 0), None)
     for trial in range(100):
         qs.array = []
         for i in range(10000):
             qs.array.append(random.randrange(-100000, 100000))
         copyqs = list(qs.array)
         copyqs.sort()
         qs.exchanger(0, 9999)
         self.assertEquals(qs.array, copyqs)
Ejemplo n.º 11
0
    def run():

        # orig_obj_values = [ "apple", "orange", "banana", "apple", "coconut", "olive", "egg", "banana", "ham", "milk", "coconut", "cheese" ]

        value_count = 10000

        orig_obj_values = np.empty(shape=(value_count))

        min = value_count + 1
        max = -1
        for i in range(value_count):
            # in c#, random.next(incl, excl), but in python, randint(incl, incl)
            v = random.randint(0, value_count - 1)

            if v < min: min = v
            if v > max: max = v

            orig_obj_values[i] = int(v)

        obj_values = np.empty_like(orig_obj_values)
        obj_values[:] = orig_obj_values

        algorithms = np.array([
            BubbleSort(),
            SelectionSort(),
            InsertionSort(),
            QuickSort(),
            MergeSort(),
            CountingSort(min, max),
            HeapSort(),
            RadixSort()
        ])

        print("Python")
        print("STARTED --------------------------------------------")

        for algorithm in algorithms:

            # reset input values
            obj_values[:] = orig_obj_values

            algorithm.run(obj_values)

        print(" ")
        print("STOPPED --------------------------------------------")
Ejemplo n.º 12
0
class QuickSortTester(unittest.TestCase):
    def setUp(self):
        self.qs = QuickSort()

    def test_partition(self):
        arr = [10, 5, 2, 90, 61, 32, 3]
        #pivot point is 10
        #after partition array should be
        #[5, 2, 3, 10, 90, 61, 32]
        result = self.qs.partition(arr, 0,
                                   len(arr) - 1)
        self.assertEqual(arr[3], 10)
        self.assertTrue(arr[0] <= 10)
        self.assertTrue(arr[1] <= 10)
        self.assertTrue(arr[2] <= 10)
        self.assertTrue(arr[4] >= 10)
        self.assertTrue(arr[5] >= 10)
        self.assertTrue(arr[6] >= 10)

    def test_quick_sort(self):
        arr = [11, 5, 7, 2, 76, 31, 20, 3, 9]
        result = self.qs.quick_sort(arr)
        self.assertEqual(arr, [2, 3, 5, 7, 9, 11, 20, 31, 76])

    def test_quick_sort_on_already_sorted_input(self):
        arr = [1, 2, 3, 4, 5]
        result = self.qs.quick_sort(arr)
        self.assertEqual(arr, result)

    def test_quick_sort_on_partially_sorted_array(self):
        arr = [1, 2, 10, 4, 90, 1001, 23]
        result = self.qs.quick_sort(arr)
        self.assertEqual(result, [1, 2, 4, 10, 23, 90, 1001])

    def test_quick_sort_on_single_element_array(self):
        arr = [9]
        result = self.qs.quick_sort(arr)
        self.assertEqual(result, [9])

    def test_quick_sort_on_two_element_array(self):
        arr = [2, 1]
        result = self.qs.quick_sort(arr)
        self.assertEqual(result, [1, 2])

        arr = [1, 2]
        result = self.qs.quick_sort(arr)
        self.assertEqual(result, [1, 2])
Ejemplo n.º 13
0
 def test_exchanger(self):
     qs = QuickSort()
     # A list of len <= 1 should return the list itself
     self.assertEquals(qs.exchanger(10, 10), None)
     self.assertEquals(qs.exchanger(10, 0), None)
     for trial in range(100):
         qs.array = []
         for i in range(10000):
             qs.array.append(random.randrange(-100000, 100000))
         copyqs = list(qs.array)
         copyqs.sort()
         qs.exchanger(0, 9999)
         self.assertEquals(qs.array, copyqs)
Ejemplo n.º 14
0
class QuickSortTester(unittest.TestCase):
    def setUp(self):
        self.qs = QuickSort()

    def test_partition(self):
        arr = [10, 5, 2, 90, 61, 32, 3]
        #pivot point is 10
        #after partition array should be
        #[5, 2, 3, 10, 90, 61, 32]
        result = self.qs.partition(arr, 0, len(arr)-1);
        self.assertEqual(arr[3], 10)
        self.assertTrue(arr[0] <= 10)
        self.assertTrue(arr[1] <= 10)
        self.assertTrue(arr[2] <= 10)
        self.assertTrue(arr[4] >= 10)
        self.assertTrue(arr[5] >= 10)
        self.assertTrue(arr[6] >= 10)

    def test_quick_sort(self):
        arr = [11, 5, 7, 2, 76, 31, 20, 3, 9]
        result = self.qs.quick_sort(arr)
        self.assertEqual(arr, [2, 3, 5, 7, 9, 11, 20, 31, 76])

    def test_quick_sort_on_already_sorted_input(self):
        arr = [1, 2, 3, 4, 5]
        result = self.qs.quick_sort(arr)
        self.assertEqual(arr, result)

    def test_quick_sort_on_partially_sorted_array(self):
        arr = [1, 2, 10, 4, 90, 1001, 23]
        result = self.qs.quick_sort(arr)
        self.assertEqual(result, [1, 2, 4, 10, 23, 90, 1001])

    def test_quick_sort_on_single_element_array(self):
        arr = [9]
        result = self.qs.quick_sort(arr)
        self.assertEqual(result, [9])

    def test_quick_sort_on_two_element_array(self):
        arr = [2, 1]
        result = self.qs.quick_sort(arr)
        self.assertEqual(result, [1, 2])

        arr = [1, 2]
        result = self.qs.quick_sort(arr)
        self.assertEqual(result, [1, 2])
Ejemplo n.º 15
0
def main():
    # Sort the following array: [43, 1, 32, 7, 12, 56, 2, 14]
    print('1. Test QuickSort algorithm')
    a = [43, 1, 32, 7, 12, 56, 2, 14]
    print('array before quicksort: {}'.format(a))
    s = QuickSort()
    s.sort(list(a))
    print('array after quicksort: {}\n'.format(s.numbers))

    # Test runtimes
    print('2. Test runtimes')
    random.seed(0)
    array_size = 1000
    dataset1 = [random.randint(0, array_size) for i in range(array_size)]
    dataset2 = sorted(dataset1)
    dataset3 = list(reversed(dataset2))
    datasets = [dataset1, dataset2, dataset3]

    for pivot in ['middle', 'first', 'last', 'random']:
        print('Test quicksort with {} element as pivot'.format(pivot))
        for i, dataset in enumerate(datasets):
            if i == 0:
                print('time if dataset unsorted:')
            if i == 1:
                print('time if dataset already sorted:')
            if i == 2:
                print('time if dataset sorted in reverse order:')
            times = []
            for i in range(10):
                start = time.time()
                s = QuickSort(pivot=pivot)
                s.sort(list(dataset))
                end = time.time()
                times.append(end - start)
            print(np.mean(times))
        print('---------------')
Ejemplo n.º 16
0
 def setUp(self):
     self.merge_sort = MergeSort()
     self.quick_sort = QuickSort()
Ejemplo n.º 17
0
def main():
    check = Check()
    create = CreateRandomList()
    selectionSort = SelectionSort()
    bubbleSort = BubbleSort()
    insertionSort = InsertionSort()
    mergeSort = MergeSort()
    quickSort = QuickSort()
    heapSort = HeapSort()

    while True:
        system("cls")
        print(menu1)
        choice0 = input("Enter a number = ")
        if choice0 == "1":
            system("cls")

            small = int(input("Enter smallest number = "))
            big = int(input("Enter biggest number = "))
            length = int(input("Enter length = "))

            if check.checkLength(length) == True and check.checkSmallBig(small, big) == True:
                aList = create.createList(small, big, length)
                print(createdList.format(aList), end="\n\n")
                while True:
                    print(menu2)
                    choice1 = input("Enter a number = ")

                    if choice1 == "1":
                        tempList = aList.copy()
                        print(createdList.format(tempList), end="\n\n")
                        selectionSort.sort(tempList)
                        input(string1)
                    elif choice1 == "2":
                        tempList = aList.copy()
                        print(createdList.format(tempList), end="\n\n")
                        bubbleSort.sort(tempList)
                        input("PRESS ENTER or ANY INPUT")
                    elif choice1 == "3":
                        tempList = aList.copy()
                        print(createdList.format(tempList), end="\n\n")
                        insertionSort.sort(tempList)
                        input("PRESS ENTER or ANY INPUT")
                    elif choice1 == "4":
                        tempList = aList.copy()
                        print(createdList.format(tempList), end="\n\n")
                        mergeSort.sort(tempList)
                        input("PRESS ENTER or ANY INPUT")
                    elif choice1 == "5":
                        tempList = aList.copy()
                        print(createdList.format(tempList), end="\n\n")
                        quickSort.sort(tempList, 0, len(tempList)-1)
                        input("PRESS ENTER or ANY INPUT")
                    elif choice1 == "6":
                        tempList = aList.copy()
                        print(createdList.format(tempList), end="\n\n")
                        heapSort.sort(tempList)
                        input("PRESS ENTER or ANY INPUT")



            else:
                input("PRESS ENTER or ANY INPUT")
        elif choice0 == "0":
            quit()
Ejemplo n.º 18
0
 def test_quicksort(self):
     qs = QuickSort()
     # Base case: empty list or list of one element should return itself
     self.assertEquals(qs.quicksort(), [])
     qs.array = [1]
     self.assertEquals(qs.quicksort(), [1])
Ejemplo n.º 19
0
def main():
    """
    Main method
    :return:
    """
    s = QuickSort()
    num_list = read_in_list(input('Enter in location of file: '))
    p_type = validate_pivot_type(input('Enter in which type of pivot you want to use: '))
    if p_type == 'first':
        s.first_quicksort(num_list, 0, len(num_list) - 1)
    elif p_type == 'last':
        s.end_quicksort(num_list, 0, len(num_list) - 1)
    else:
        s.mid_quicksort(num_list, 0, len(num_list) - 1)
    print(num_list)
    print("Count: ")
    s.get_count()
    s.reset_count()
from Utils import Utils
from QuickSort import QuickSort
from MergeSort import MergeSort
from InsertionSort import InsertionSort
from SelectionSort import SelectionSort
from BubbleSort import BubbleSort

# QUICK SORT

print("----- QUICK SORT -----\n")

numbers = Utils.get_numbers()
print("Unsorted numbers", numbers)
print("Sorted numbers", QuickSort.sort(numbers))

characters = Utils.get_characters()
print("Unsorted characters", characters)
print("Sorted characters", QuickSort.sort(characters))

strings = Utils.get_strings()
print("Unsorted strings", strings)
print("Sorted stirngs", QuickSort.sort(strings))

# MERGE SORT
print("\n----- QUICK SORT -----\n")

numbers = Utils.get_numbers()
print("Unsorted numbers", numbers)
print("Sorted numbers", MergeSort.sort(numbers))

characters = Utils.get_characters()
Ejemplo n.º 21
0
 def __init__(self, array: List, value: int):
     a = array[:]
     QuickSort(a)
     # self.result = self.search(a, value)
     self.result = self.search_recursive(a, value, 0, len(a) - 1)
Ejemplo n.º 22
0
 def setUp(self):
     self.qs = QuickSort()
Ejemplo n.º 23
0
#Binary search

from QuickSort import QuickSort


def SearchElementInArray(arr, element, min, max):
    #Base case of recursion
    if max >= min:
        #Find the index of half array
        MidElement = min + (max - min) // 2

        #If the element to find catch with "MidElement" return it
        if arr[MidElement] == element:
            return MidElement
        #if the element to find is less than element in "MidElement" index search just on the left way
        elif arr[MidElement] > element:
            return SearchElementInArray(arr, element, min, MidElement - 1)
        #else search just on the right way
        else:
            return SearchElementInArray(arr, element, MidElement + 1, max)
    else:
        return -1


if __name__ == '__main__':
    Arr = [14, 17, 16, 18, 6]
    x = 17
    Sort = QuickSort(Arr)
    res = SearchElementInArray(Arr, x, 0, len(Arr) - 1)
    print(res)
Ejemplo n.º 24
0
 def test_getpivot(self):
     qs = QuickSort()
     # Basic case, find middle of three, regardless of location in list
     qs.array = [1, 2, 3]
     self.assertEquals(qs.getpivot(0, 2), 2)
     qs.array = [2, 1, 3]
     self.assertEquals(qs.getpivot(0, 2), 2)
     qs.array = [1, 3, 2]
     self.assertEquals(qs.getpivot(0, 2), 2)
     # One-item list
     qs.array = [-7]
     self.assertEquals(qs.getpivot(0, 0), -7)
     # List of the same item repeated
     qs.array = [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
     self.assertEquals(qs.getpivot(0, 9), 2)
     # Find middle of three when they're the same and the list is longer
     qs.array = [10, 2, 2, 2, 10, 2, 2, 2, 2, 10]
     self.assertEquals(qs.getpivot(0, 9), 10)
     # Find middle of three when only two are the same
     qs.array = [10, 2, 2, 2, 10, 2, 2, 2, 2, 0]
     self.assertEquals(qs.getpivot(0, 9), 10)
     qs.array = [0, 2, 2, 2, 10, 2, 2, 2, 2, 10]
     self.assertEquals(qs.getpivot(0, 9), 10)
     qs.array = [10, 2, 2, 2, 0, 2, 2, 2, 2, 10]
     self.assertEquals(qs.getpivot(0, 9), 10)
Ejemplo n.º 25
0
 def test_quicksort(self):
     qs = QuickSort()
     # Base case: empty list or list of one element should return itself
     self.assertEquals(qs.quicksort(), [])
     qs.array = [1]
     self.assertEquals(qs.quicksort(), [1])
Ejemplo n.º 26
0
from QuickSort import QuickSort

L1 = [4, 1, 3, 6, 2, 8, 10, 40, 30, 11, 9]
L2 = [100, 90, 80, 70, 60, 50, 40, 30, 20, 10]
L3 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

obj = QuickSort(L2)
print(obj.sort())
Ejemplo n.º 27
0
 def test_getpivot(self):
     qs = QuickSort()
     # Basic case, find middle of three, regardless of location in list
     qs.array = [1, 2, 3]
     self.assertEquals(qs.getpivot(0, 2), 2)
     qs.array = [2, 1, 3]
     self.assertEquals(qs.getpivot(0, 2), 2)
     qs.array = [1, 3, 2]
     self.assertEquals(qs.getpivot(0, 2), 2)
     # One-item list
     qs.array = [-7]
     self.assertEquals(qs.getpivot(0, 0), -7)
     # List of the same item repeated
     qs.array = [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
     self.assertEquals(qs.getpivot(0, 9), 2)
     # Find middle of three when they're the same and the list is longer
     qs.array = [10, 2, 2, 2, 10, 2, 2, 2, 2, 10]
     self.assertEquals(qs.getpivot(0, 9), 10)
     # Find middle of three when only two are the same
     qs.array = [10, 2, 2, 2, 10, 2, 2, 2, 2, 0]
     self.assertEquals(qs.getpivot(0, 9), 10)
     qs.array = [0, 2, 2, 2, 10, 2, 2, 2, 2, 10]
     self.assertEquals(qs.getpivot(0, 9), 10)
     qs.array = [10, 2, 2, 2, 0, 2, 2, 2, 2, 10]
     self.assertEquals(qs.getpivot(0, 9), 10)
Ejemplo n.º 28
0
 def setUp(self):
     self.qs = QuickSort()
from QuickSort import QuickSort

quick_sort = QuickSort()

arr = [4, 5, 22, 4, 2, 1, 5, 7]

quick_sort.sort(arr)
print(arr)
Ejemplo n.º 30
0
from Bank import Bank
from QuickSort import QuickSort
from SelectionSort import SelectionSort

if __name__ == "__main__":
    banks_list = []
    name_pos = 0
    clients_pos = 1
    credits_pos = 2
    file = open('banks_list.csv')
    for line in file:
        values = line.split(',')
        bank = Bank(values[name_pos], int(values[clients_pos]),
                    int(values[credits_pos][:-1]))
        banks_list.append(bank)

    print("Selection sort:")
    selection_sort = SelectionSort(banks_list)
    start_time = time.clock()
    selection_sort.selection_sort()
    print("Time: " + str(time.clock() - start_time))
    for bank in banks_list:
        print(bank)

    print("\nQUICK sort:")
    quick_sort = QuickSort(banks_list)
    start_time = time.clock()
    quick_sort.quick_sort()
    print("Time: " + str(time.clock() - start_time))
    for bank in banks_list:
        print(bank)
Ejemplo n.º 31
0
        values_add, values_min, values_max = elabora(BubbleSort(True),
                                                     this_list, rounds,
                                                     repetitions)
        print("BubbleSort(True) done!")
        values_quickbubble_add.append(values_add)
        values_quickbubble_min.append(values_min)
        values_quickbubble_max.append(values_max)
        values_add, values_min, values_max = elabora(BubbleSort(False),
                                                     this_list, rounds,
                                                     repetitions)
        print("BubbleSort(False) done!")
        values_bubble_add.append(values_add)
        values_bubble_min.append(values_min)
        values_bubble_max.append(values_max)
        values_add, values_min, values_max = elabora(QuickSort(), this_list,
                                                     rounds, repetitions)
        print("QuickSort() done!")
        values_quicksort_add.append(values_add)
        values_quicksort_min.append(values_min)
        values_quicksort_max.append(values_max)
        values_add, values_min, values_max = elabora(BinarySearchTree(),
                                                     this_list, rounds,
                                                     repetitions)
        print("BinarySearchTree() done!")
        values_binarytree_add.append(values_add)
        values_binarytree_min.append(values_min)
        values_binarytree_max.append(values_max)
        values_add, values_min, values_max = elabora(HeapSort(), this_list,
                                                     rounds, repetitions)
        print("HeapSort() done!")
    def control_menu_Quicksort(self):
        opc2 = 0  # Inicializa opc2.
        cInterfaz = Interfaz()
        qs = QuickSort([6, 3, 2, 7, 5, 2, 4, 8,
                        777])  # Creo el objeto Interfaz.
        #___________________________________________________________ Inicio del ciclo while - Iterar menú.
        while (
                opc2 != 7
        ):  # ///////////// Numero a poner el de la opcion SALIR ///////////////////////
            os.system('cls')  # Limpia pantalla
            cInterfaz.menu_Quicksort()  # Llama método externo.
            opc2 = int(input("\nIngrese la opcion: ")
                       )  # Aquí almacenamos en opc2 lo que digite el usuario.
            #------------------------------------------------------- Bloque de evaluación para menu quicksort.
            if opc2 == 1:
                os.system("cls")
                print("---- Creando Lista ----")
                a = self.crearLista()
                qs.setQ(a)
            elif opc2 == 2:
                os.system("cls")
                print("---- Ordenando Lista ----")
                qs.quickSortRandom(qs.Q, 0, len(qs.Q) - 1)
                print(qs.Q)
                input("\nPresione TECLA para continuar...")
            elif opc2 == 3:
                os.system("cls")
                print("---- Ordenando Lista ----")
                qs.quickSort(qs.Q, 0, len(qs.Q) - 1)
                print(qs.Q)
                input("\nPresione TECLA para continuar...")
            elif opc2 == 4:
                os.system("cls")
                print("---- Timing del QuickSort ----")
                qs.timing_quickSort_Rand()
                input("\nPresione TECLA para continuar...")
            elif opc2 == 5:
                os.system("cls")
                print("---- Timing del QuickSort ----")
                qs.timing_quickSort()
                input("\nPresione TECLA para continuar...")
            elif opc2 == 6:
                os.system("cls")
                print("---- Guardadndo csv del QuickSort ----")
                qs.quickSort_rand_time_save()
                qs.quickSort_time_save()
                input("\nPresione TECLA para continuar...")

            #qs.quickSort()
            #------------------------------------------------------- Fin bloque de evaluación.
            #_______________________________________________________ Fin bloque while.
        pass
Ejemplo n.º 33
0
    start_time = timeit.default_timer()
    sortObject.sort(input)
    elapsed = timeit.default_timer() - start_time
    return elapsed * 100


#Input Sizes
inputSizes = [
    1000, 2000, 5000, 10000, 20000, 25000, 40000, 50000, 60000, 75000, 100000
]

#Creating objects of sorting implementation and data Creation utility
data = CreateDataUtility()
insertionSort = InsertionSort()
mergeSort = MergeSort()
quickSort = QuickSort()
modifiedQuickSort = ModifiedQuickSort()

#Creating a csv file with results in "Results/" folder
with open('Results/Running-times-average-case.csv', mode='w') as csv_file:
    writer = csv.writer(csv_file, delimiter=',')
    writer.writerow(['Sort Algorithm', 'input Size', 'Time Taken'])
    for inputSize in inputSizes:
        input = data.CreateAverageCaseData(inputSize)
        sys.setrecursionlimit(max(sys.getrecursionlimit(), len(input) + 50000))
        insertionSortInput = []
        insertionSortInput.extend(input)
        mergeSortInput = []
        mergeSortInput.extend(input)
        quickSortInput = []
        quickSortInput.extend(input)
Ejemplo n.º 34
0
#!/usr/bin/env python
"""A little test-suite for me to test the speeds of algorithms.
"""

from timeit import timeit
from random import randrange
from InsertionSort import InsertionSort
from BubbleSort import BubbleSort
from QuickSort import QuickSort
from MergeSort import MergeSort

TIMES = 1
SORT_COUNT = 10001
dataset = [randrange(1, 1000) for _ in range(SORT_COUNT)]

insertionsort_time = timeit(lambda: InsertionSort(dataset), number=TIMES)
bubblesort_time = timeit(lambda: BubbleSort(dataset), number=TIMES)
quicksort_time = timeit(lambda: QuickSort(dataset), number=TIMES)
mergesort_time = timeit(lambda: MergeSort(dataset), number=TIMES)

print(f"Sorted {SORT_COUNT - 1} integers.")
print(
    f"Execution time of InsertionSort, executed {TIMES} times: {insertionsort_time}"
)
print(
    f"Execution time of Bubblesort, executed {TIMES} times: {bubblesort_time}")
print(f"Execution time of QuickSort, executed {TIMES} times: {quicksort_time}")
print(f"Execution time of MergeSort, executed {TIMES} times: {mergesort_time}")