def callInsertionSort(list):
start_time = time.time()
insertion_sort.insertionSort(list)
insertionSort_time = (time.time() - start_time)
print("\nInsertion Sort --- %s ---\n" % insertionSort_time)
#print(list)
print("\n")
def bucketSort(myList, bucketSize=DEFAULT_BUCKET_SIZE):
if (len(myList) == 0):
print('You don\'t have any elements in array!')
minValue = myList[0]
maxValue = myList[0]
# For finding minimum and maximum values
for i in range(0, len(myList)):
if myList[i] < minValue:
minValue = myList[i]
elif myList[i] > maxValue:
maxValue = myList[i]
# Initialize buckets
bucketCount = math.floor((maxValue - minValue) / bucketSize) + 1
buckets = []
for i in range(0, bucketCount):
buckets.append([])
# For putting values in buckets
for i in range(0, len(myList)):
buckets[math.floor(
(myList[i] - minValue) / bucketSize)].append(myList[i])
# Sort buckets and place back into input array
sortedArray = []
for i in range(0, len(buckets)):
insertionSort(buckets[i])
for j in range(0, len(buckets[i])):
sortedArray.append(buckets[i][j])
return sortedArray
def bucketSort(numbers):
length = len(numbers)
buckets = [[] for _ in range(length)]
for n in numbers:
buckets[n // length].append(n)
for b in buckets:
if b:
insertionSort(b)
numbers = np.array([num for bucket in buckets for num in bucket])
return numbers
def start():
global data
if var.get() == OptionList[0]:
bub_sort(data, drawdata, speed.get())
if var.get() == OptionList[1]:
mergeSort(data, 0, int(data_size.get()) - 1, drawdata, speed.get())
if var.get() == OptionList[2]:
insertionSort(data, drawdata, speed.get())
if var.get() == OptionList[3]:
quickSort(data, 0, int(data_size.get()) - 1, drawdata, speed.get())
def methodTester(sortMethod, baseSize=10):
#store the sorted file names
sorted_files = []
# Create the random number files
files = _fileCreator(baseSize)
# Create the time table file
timing_file = open(str(sortMethod) + "Sort_test_times", 'w')
timing_file.write("Input Size (n): Time cost:")
# For each of the files:
for file in files:
# Create a list from the numbers stored in the file
number_list = _fileToList(file)
number_count = len(number_list)
for i in range(number_count):
number_list[i] = float(number_list[i])
# Create the file to store the sorted list
sortedFileName = str(file) + "_" + sortMethod + "sort_sorted"
sorted_files.append(sortedFileName)
sortedFile = open(sortedFileName, 'w')
# Check sorting method, then sort while timing
if sortMethod == 'merge':
start_time = time.time()
numberListSorted = mSort.mergeSort(number_list, 1,
len(number_list))
stop_time = time.time()
elif sortMethod == 'quick':
start_time = time.time()
numberListSorted = qSort.quickSort(number_list, 0,
len(number_list) - 1)
stop_time = time.time()
elif sortMethod == 'insertion':
start_time = time.time()
numberListSorted = iSort.insertionSort(number_list,
len(number_list))
stop_time = time.time()
else:
print('''Uh oh, the provided sort method has yet to be implemented!
Please use either 'merge', 'quick', or 'insertion'.\n''')
# Store the sorted list in its respective file
sortedFile.write(str(numberListSorted))
sortedFile.close()
# Calculate the time taken, then add it to the timing file
sort_time = stop_time - start_time
timing_file.write("\n" + str(number_count) + " " + str(sort_time))
# Close the timing file, and prompt the user on whether
# or not to delete the created files used to calculate
# the timing data.
timing_file.close()
files.extend(sorted_files)
_askDelete(files)
def test_large_inputs(self):
print("Testing large inputs...")
random_list = random.sample(range(-800000, 800000), 10000)
sorted_random_list = sorted(random_list)
self.assertEqual(bubbleSort(random_list), sorted_random_list)
self.assertEqual(insertionSort(random_list), sorted_random_list)
self.assertEqual(selectionSort(random_list), sorted_random_list)
def compare_merge_insert():
N = 10**4 # change here to change array size. 10**4 is enough big, it takes about 5 seconds.
arr_insert = [random.randint(0, 10**6) for _ in range(N)]
arr_merge = copy.deepcopy(arr_insert)
start_time = time.time()
insertion_sort.insertionSort(arr_insert)
insert_time = time.time() - start_time
start_time = time.time()
merge_sort.mergeSort(arr_merge)
merge_time = time.time() - start_time
# check error
for i, n in enumerate(arr_insert):
if n != arr_merge[i]:
print("Error: result is not the same!, ", i)
return
print("result is the same")
print("insert sort time = ", insert_time)
print("merge sort time = ", merge_time)
def analyze_text(book, text):
'''Performs a very naive analysis of the words in the text, returning the SORTED list of WordData items'''
# lowercase the entire text
with open(text, 'r') as f:
all_words = f.read()
all_words = all_words.lower()
# split the text by whitespace to get a list of words
string_file = re.split('\s+', all_words)
words = []
for i in string_file:
new_i = re.findall("[a-z]+", i)
if len(new_i) > 1:
# convert each word to the longest run of characters
if len(new_i[0]) >= len(new_i[1]):
del new_i[1]
else:
del new_i[0]
# eliminate any words that are empty after conversion to characters
if new_i:
words.append(new_i)
# count up the occurance of each word into a dictionary of: word -> count
agg_words = {}
for w in words:
if w[0] in agg_words:
temp_count = agg_words[w[0]]
temp_count += 1
agg_words[w[0]] = temp_count
else:
agg_words[w[0]] = 1
# create a WordData item for each word in our list of words
word_objects = []
for key in agg_words:
# percent needs to be stored rounded to 1 decimal or the printing doesn't work correctly
wordData = WordData(book, key, agg_words[key],
round(agg_words[key] / len(words) * 100, 1))
word_objects.append(wordData)
# sort the WordData list using Bubble Sort, Insertion Sort, or Selection Sort:
# 1. highest percentage [descending]
# 2. highest count (if percentages are equal) [descending]
# 3. lowest alpha order (if percentages and count are equal) [ascending]
# sorted_words = bubbleSort(word_objects)
sorted_words = insertionSort(word_objects)
# sorted_words = selectionSort(word_objects)
return sorted_words
def bucketSort(Arr):
max_value = max(Arr)
size = max_value / len(Arr)
buckets_list = []
for x in range(len(Arr)): # create buckets
buckets_list.append([])
for y in range(len(Arr)):
z = int(Arr[y] / size)
if (z != len(Arr)):
buckets_list[z].append(Arr[y])
else:
buckets_list[len(Arr) - 1].append(Arr[y])
for z in range(len(Arr)): # use previously implemented insertion sort
iSort.insertionSort(buckets_list[z])
Arr_out = []
for x in range(len(Arr)): # combine buckets into final output
Arr_out = Arr_out + buckets_list[x]
return Arr_out
def drawAllGraph():
insertionTimes = [] #[0.0, 0.03, 9.9, 29.86] #10**k for k = 1,3,6,9
selectionTimes = []
mergeTimes = [] #[0.0, 0.0, 5.33, 29.9 ]
arraySizes = [10**i for i in range(1, 5)]
for i in arraySizes:
randomList = np.random.random_integers(1, 10000000, size=i)
startTime = time.time()
sel_list = selection_sort.selectionSort(
np.random.random_integers(1, 10000000, size=i))
runTime = time.time() - startTime
selectionTimes.append(runTime)
startTime = time.time()
merge_list = MERGE.mergeSort(
np.random.random_integers(1, 10000000, size=i))
runTime = time.time() - startTime
mergeTimes.append(runTime)
startTime = time.time()
insertion_list = insertion_sort.insertionSort(
np.random.random_integers(1, 10000000, size=i))
runTime = time.time() - startTime
insertionTimes.append(runTime)
plt.figure(figsize=(12, 5))
plt.plot(arraySizes,
selectionTimes,
marker='x',
c='b',
label='Selectionsort')
plt.plot(arraySizes, mergeTimes, marker='x', c='r', label='Mergesort')
plt.plot(arraySizes,
insertionTimes,
marker='x',
c='g',
label='Insertionsort')
plt.xscale('log')
plt.yscale('log')
plt.xlabel("size of unsorted list - log scale")
plt.ylabel("seconds of computation - log scale")
plt.legend(loc=2)
plt.grid()
plt.title("Selectionsort vs Mergesort vs Insertionsort")
plt.show()
#http://nixonite.github.io/posts/complexity-of-algorithms-with-python.html
def bucketSort(customList):
numberofBuckets = round(math.sqrt(len(customList)))
maxValue = max(customList)
arr = []
for i in range(numberofBuckets):
arr.append([])
for j in customList:
index_b = math.ceil(j * numberofBuckets / maxValue)
arr[index_b - 1].append(j)
for i in range(numberofBuckets):
arr[i] = sort.insertionSort(arr[i])
k = 0
for i in range(numberofBuckets):
for j in range(len(arr[i])):
customList[k] = arr[i][j]
k += 1
return customList
def test_empty_input(self):
print("Testing edge cases...")
self.assertEqual(bubbleSort([]), [])
self.assertEqual(insertionSort([]), [])
self.assertEqual(selectionSort([]), [])
def test_insertionSort_array_last_val(self):
words = self.test_create_WordData_array()
sorted_words = insertionSort(words)
self.assertEqual(sorted_words[7].word, 'm')
def test_nativeSort_fail(self):
arr = self.test_create_array()
sorted_arr = insertionSort(arr)
self.assertEqual(sorted_arr[7], 1)
def test_insertionSort_array_last_val(self):
arr = self.test_create_array()
sorted_arr = insertionSort(arr)
self.assertEqual(sorted_arr[3], 2)
def testInsertionSort_repeatedValues_sorts(self):
A = [2, 3, 4, 3, 2, 3, 1] # Example from CLRS p.18 3rd ed.
sort.insertionSort(A)
self.assertEquals(A, [1, 2, 2, 3, 3, 3, 4])
def testInsertionSort_stringInput_sorts(self):
A = ['e', 'b', 'd', 'f', 'a', 'c']
sort.insertionSort(A)
self.assertEquals(A, ['a', 'b', 'c', 'd', 'e', 'f'])
def testInsertionSort_integerInput_sorts(self):
A = [5, 2, 4, 6, 1, 3] # Example from CLRS p.18 3rd ed.
sort.insertionSort(A)
self.assertEquals(A, [1, 2, 3, 4, 5, 6])
def testInsertionSort_sizeOnearray_isNoop(self):
A = [42]
sort.insertionSort(A)
self.assertEquals(A, [42])
def test_insertionSort(self):
self.assertEqual(insertionSort([8, 5, 2, 9, 5, 6, 3]),
[2, 3, 5, 5, 6, 8, 9])
self.assertEqual(insertionSort([1]), [1])
self.assertEqual(insertionSort([1, 2]), [1, 2])
self.assertEqual(insertionSort([2, 1]), [1, 2])
self.assertEqual(insertionSort([1, 3, 2]), [1, 2, 3])
self.assertEqual(insertionSort([3, 1, 2]), [1, 2, 3])
self.assertEqual(insertionSort([1, 2, 3]), [1, 2, 3])
self.assertEqual(
insertionSort([
-4, 5, 10, 8, -10, -6, -4, -2, -5, 3, 5, -4, -5, -1, 1, 6, -7,
-6, -7, 8
]), [
-10, -7, -7, -6, -6, -5, -5, -4, -4, -4, -2, -1, 1, 3, 5, 5, 6,
8, 8, 10
])
self.assertEqual(
insertionSort([
-7, 2, 3, 8, -10, 4, -6, -10, -2, -7, 10, 5, 2, 9, -9, -5, 3, 8
]),
[-10, -10, -9, -7, -7, -6, -5, -2, 2, 2, 3, 3, 4, 5, 8, 8, 9, 10])
self.assertEqual(
insertionSort([
8, -6, 7, 10, 8, -1, 6, 2, 4, -5, 1, 10, 8, -10, -9, -10, 8, 9,
-2, 7, -2, 4
]), [
-10, -10, -9, -6, -5, -2, -2, -1, 1, 2, 4, 4, 6, 7, 7, 8, 8, 8,
8, 9, 10, 10
])
self.assertEqual(
insertionSort([5, -2, 2, -8, 3, -10, -6, -1, 2, -2, 9, 1, 1]),
[-10, -8, -6, -2, -2, -1, 1, 1, 2, 2, 3, 5, 9])
self.assertEqual(
insertionSort([
2, -2, -6, -10, 10, 4, -8, -1, -8, -4, 7, -4, 0, 9, -9, 0, -9,
-9, 8, 1, -4, 4, 8, 5, 1, 5, 0, 0, 2, -10
]), [
-10, -10, -9, -9, -9, -8, -8, -6, -4, -4, -4, -2, -1, 0, 0, 0,
0, 1, 1, 2, 2, 4, 4, 5, 5, 7, 8, 8, 9, 10
])
self.assertEqual(
insertionSort([
4, 1, 5, 0, -9, -3, -3, 9, 3, -4, -9, 8, 1, -3, -7, -4, -9, -1,
-7, -2, -7, 4
]), [
-9, -9, -9, -7, -7, -7, -4, -4, -3, -3, -3, -2, -1, 0, 1, 1, 3,
4, 4, 5, 8, 9
])
self.assertEqual(
insertionSort([
427, 787, 222, 996, -359, -614, 246, 230, 107, -706, 568, 9,
-246, 12, -764, -212, -484, 603, 934, -848, -646, -991, 661,
-32, -348, -474, -439, -56, 507, 736, 635, -171, -215, 564,
-710, 710, 565, 892, 970, -755, 55, 821, -3, -153, 240, -160,
-610, -583, -27, 131
]), [
-991, -848, -764, -755, -710, -706, -646, -614, -610, -583,
-484, -474, -439, -359, -348, -246, -215, -212, -171, -160,
-153, -56, -32, -27, -3, 9, 12, 55, 107, 131, 222, 230, 240,
246, 427, 507, 564, 565, 568, 603, 635, 661, 710, 736, 787,
821, 892, 934, 970, 996
])
self.assertEqual(
insertionSort([
991, -731, -882, 100, 280, -43, 432, 771, -581, 180, -382,
-998, 847, 80, -220, 680, 769, -75, -817, 366, 956, 749, 471,
228, -435, -269, 652, -331, -387, -657, -255, 382, -216, -6,
-163, -681, 980, 913, -169, 972, -523, 354, 747, 805, 382,
-827, -796, 372, 753, 519, 906
]), [
-998, -882, -827, -817, -796, -731, -681, -657, -581, -523,
-435, -387, -382, -331, -269, -255, -220, -216, -169, -163,
-75, -43, -6, 80, 100, 180, 228, 280, 354, 366, 372, 382, 382,
432, 471, 519, 652, 680, 747, 749, 753, 769, 771, 805, 847,
906, 913, 956, 972, 980, 991
])
self.assertEqual(
insertionSort([
384, -67, 120, 759, 697, 232, -7, -557, -772, -987, 687, 397,
-763, -86, -491, 947, 921, 421, 825, -679, 946, -562, -626,
-898, 204, 776, -343, 393, 51, -796, -425, 31, 165, 975, -720,
878, -785, -367, -609, 662, -79, -112, -313, -94, 187, 260, 43,
85, -746, 612, 67, -389, 508, 777, 624, 993, -581, 34, 444,
-544, 243, -995, 432, -755, -978, 515, -68, -559, 489, 732,
-19, -489, 737, 924
]), [
-995, -987, -978, -898, -796, -785, -772, -763, -755, -746,
-720, -679, -626, -609, -581, -562, -559, -557, -544, -491,
-489, -425, -389, -367, -343, -313, -112, -94, -86, -79, -68,
-67, -19, -7, 31, 34, 43, 51, 67, 85, 120, 165, 187, 204, 232,
243, 260, 384, 393, 397, 421, 432, 444, 489, 508, 515, 612,
624, 662, 687, 697, 732, 737, 759, 776, 777, 825, 878, 921,
924, 946, 947, 975, 993
])
self.assertEqual(
insertionSort([
544, -578, 556, 713, -655, -359, -810, -731, 194, -531, -685,
689, -279, -738, 886, -54, -320, -500, 738, 445, -401, 993,
-753, 329, -396, -924, -975, 376, 748, -356, 972, 459, 399,
669, -488, 568, -702, 551, 763, -90, -249, -45, 452, -917, 394,
195, -877, 153, 153, 788, 844, 867, 266, -739, 904, -154, -947,
464, 343, -312, 150, -656, 528, 61, 94, -581
]), [
-975, -947, -924, -917, -877, -810, -753, -739, -738, -731,
-702, -685, -656, -655, -581, -578, -531, -500, -488, -401,
-396, -359, -356, -320, -312, -279, -249, -154, -90, -54, -45,
61, 94, 150, 153, 153, 194, 195, 266, 329, 343, 376, 394, 399,
445, 452, 459, 464, 528, 544, 551, 556, 568, 669, 689, 713,
738, 748, 763, 788, 844, 867, 886, 904, 972, 993
])
self.assertEqual(
insertionSort([
-19, 759, 168, 306, 270, -602, 558, -821, -599, 328, 753, -50,
-568, 268, -92, 381, -96, 730, 629, 678, -837, 351, 896, 63,
-85, 437, -453, -991, 294, -384, -628, -529, 518, 613, -319,
-519, -220, -67, 834, 619, 802, 207, 946, -904, 295, 718, -740,
-557, -560, 80, 296, -90, 401, 407, 798, 254, 154, 387, 434,
491, 228, 307, 268, 505, -415, -976, 676, -917, 937, -609, 593,
-36, 881, 607, 121, -373, 915, -885, 879, 391, -158, 588, -641,
-937, 986, 949, -321
]), [
-991, -976, -937, -917, -904, -885, -837, -821, -740, -641,
-628, -609, -602, -599, -568, -560, -557, -529, -519, -453,
-415, -384, -373, -321, -319, -220, -158, -96, -92, -90, -85,
-67, -50, -36, -19, 63, 80, 121, 154, 168, 207, 228, 254, 268,
268, 270, 294, 295, 296, 306, 307, 328, 351, 381, 387, 391,
401, 407, 434, 437, 491, 505, 518, 558, 588, 593, 607, 613,
619, 629, 676, 678, 718, 730, 753, 759, 798, 802, 834, 879,
881, 896, 915, 937, 946, 949, 986
])
self.assertEqual(
insertionSort([
-823, 164, 48, -987, 323, 399, -293, 183, -908, -376, 14, 980,
965, 842, 422, 829, 59, 724, -415, -733, 356, -855, -155, 52,
328, -544, -371, -160, -942, -51, 700, -363, -353, -359, 238,
892, -730, -575, 892, 490, 490, 995, 572, 888, -935, 919, -191,
646, -120, 125, -817, 341, -575, 372, -874, 243, 610, -36,
-685, -337, -13, 295, 800, -950, -949, -257, 631, -542, 201,
-796, 157, 950, 540, -846, -265, 746, 355, -578, -441, -254,
-941, -738, -469, -167, -420, -126, -410, 59
]), [
-987, -950, -949, -942, -941, -935, -908, -874, -855, -846,
-823, -817, -796, -738, -733, -730, -685, -578, -575, -575,
-544, -542, -469, -441, -420, -415, -410, -376, -371, -363,
-359, -353, -337, -293, -265, -257, -254, -191, -167, -160,
-155, -126, -120, -51, -36, -13, 14, 48, 52, 59, 59, 125, 157,
164, 183, 201, 238, 243, 295, 323, 328, 341, 355, 356, 372,
399, 422, 490, 490, 540, 572, 610, 631, 646, 700, 724, 746,
800, 829, 842, 888, 892, 892, 919, 950, 965, 980, 995
])
import merge_sort
n=input("Enter a integer that represents the number of elements for the sort problem you want to simulate:")
n=int(n)
arr=[]
for i in range(n):
arr.append(random.randint(0,n*10))
# printSome(arr,str="原始序列")
#深拷贝一份未排序数列
arr_bak=arr[:]
# printSome(arr_bak,str="复制的原始序列")
""" 开始比较计时:这一段可以考虑用函数式编程(函数作为参数) """
#统计插入排序的耗时
start_time1=time()
printSome(arr,str="插入排序之前:")
insertion_sort.insertionSort(arr)
end_time1=time()
printSome(arr,str="插入排序之后:")
print("the insertion sort takes time:%s" % (end_time1-start_time1))
#统计归并排序的耗时
start_time2=time()
printSome(arr_bak,str="归并排序之前:")
#注意,此归并排序的结果以MergeSort()函数返回来获得,并不会直接在参数列表中改动
arr_bak=merge_sort.MergeSort(arr_bak)
end_time2=time()
printSome(arr_bak,str="归并排序之后:")
print("the MergeSort sort takes time:%s" % (end_time2-start_time2))
def testSort(tests, n, minimum, maximum):
time = [datetime.timedelta(0)] * 6
for i in range(tests):
ar = createArray(n, minimum, maximum)
i_sort = list(ar)
m_sort = list(ar)
q_sort = list(ar)
qr_sort = list(ar)
h_sort = list(ar)
d = datetime.datetime.now()
insertion_sort.insertionSort(i_sort)
time[0] += (datetime.datetime.now() - d)
d = datetime.datetime.now()
m_sort = merge_sort.mergeSort(m_sort)
time[1] += (datetime.datetime.now() - d)
d = datetime.datetime.now()
quick_sort.quickSort(q_sort)
time[2] += (datetime.datetime.now() - d)
d = datetime.datetime.now()
quick_sort.quickSortRand(qr_sort)
time[3] += (datetime.datetime.now() - d)
d = datetime.datetime.now()
h_sort = heap_sort.heapSort(h_sort)
time[4] += (datetime.datetime.now() - d)
d = datetime.datetime.now()
bible = sorted(ar)
time[5] += (datetime.datetime.now() - d)
error = False
if not compareArrays(bible, i_sort):
print "Insertion sort error: ar =", ar, ", i_sort =", i_sort, ", bible =", bible
error = True
if not compareArrays(bible, m_sort):
print "Merge sort error: ar =", ar, ", m_sort =", m_sort, ", bible =", bible
error = True
if not compareArrays(bible, q_sort):
print "Quick sort (deterministic) error: ar =", ar, ", q_sort =", q_sort, ", bible =", bible
error = True
if not compareArrays(bible, qr_sort):
print "Quick sort (random) error: ar =", ar, ", qr_sort =", qr_sort, ", bible =", bible
error = True
if not compareArrays(bible, h_sort):
print "Heap sort error: ar =", ar, ", h_sort =", h_sort, ", bible =", bible
error = True
if not error:
print "Test", i + 1, "successful"
print "Insertion sort time =", time[0]
print "Merge sort time =", time[1]
print "Quick sort (deterministic) time =", time[2]
print "Quick sort (random) time =", time[3]
print "Heap sort time =", time[4]
print "Default Python sort time =", time[5]
def testInsertionSort_emptyArray_isNoop(self):
A = []
sort.insertionSort(A)
self.assertEquals(A, list())
def sorting_algorithms(arrayToBeSorted):
# Calling Insertion sort and calculating time elapsed
print("\n\n*********INSERTION SORT**********")
#print("\nArray Before Sort")
arrayToBeSorted1 = list(arrayToBeSorted)
#print(arrayToBeSorted1)
startTime1 = datetime.datetime.now()
sorted_array = insertion_sort.insertionSort(arrayToBeSorted1)
endTime1 = datetime.datetime.now()
diff = endTime1 - startTime1
timeElapsed1 = diff.total_seconds() * 1000
#print ("\n\nSorted array after Insertion sort is:")
#print(sorted_array)
print("\nTime elapsed in milliseconds after Insertion sort is : ")
print(timeElapsed1)
# Calling merge sort and calculating time elapsed
print("\n\n\n*********MERGE SORT**********")
#print("\nArray Before Sort")
arrayToBeSorted2 = list(arrayToBeSorted)
#print(arrayToBeSorted2)
n = len(arrayToBeSorted2)
startTime2 = datetime.datetime.now()
merge_sort.mergeSort(arrayToBeSorted2, 0, n - 1)
endTime2 = datetime.datetime.now()
diff = endTime2 - startTime2
timeElapsed2 = diff.total_seconds() * 1000
#print ("\n\nSorted array after merge sort is")
#print (arrayToBeSorted2)
print("\n\nTime elapsed in milliseconds after Merge-sort is : ")
print(timeElapsed2)
# Calling In-place quicksort sort and calculating time elapsed
print("\n\n\n*********IN-PLACE QUICKSORT**********")
#print("\nArray Before Sort")
arrayToBeSorted3 = list(arrayToBeSorted)
#print(arrayToBeSorted3)
n = len(arrayToBeSorted3)
startTime3 = datetime.datetime.now()
inplace_quicksort.quickSort(arrayToBeSorted3, 0, n - 1)
endTime3 = datetime.datetime.now()
diff = endTime3 - startTime3
timeElapsed3 = diff.total_seconds() * 1000
#print ("\n\nSorted array after In-place quicksort is:")
#print (arrayToBeSorted3)
#for i in range(n):
#print ("%d" %arrayToBeSorted3[i]),
print("\n\nTime elapsed in milliseconds after Quicksort is : ")
print(timeElapsed3)
# Calling Modified Quicksort and calculating time elapsed
print("\n\n\n*********MODIFIED QUICKSORT**********")
#print("\nArray Before Sort")
arrayToBeSorted4 = list(arrayToBeSorted)
#print(arrayToBeSorted4)
n = len(arrayToBeSorted4)
startTime4 = datetime.datetime.now()
modified_quicksort.quickSort(arrayToBeSorted4, 0, n - 1)
endTime4 = datetime.datetime.now()
diff = endTime4 - startTime4
timeElapsed4 = diff.total_seconds() * 1000
#print ("\n\nSorted array after Modified quicksort is:")
#print (arrayToBeSorted4)
print("\n\nTime elapsed in milliseconds after Modified Quicksort is : ")
print(timeElapsed4)
