def run():
numbers = range(10000)
datas = []
times = []
sizes = [10, 100, 500, 1000, 5000, 10000, 20000, 30000]
for s in sizes:
datas.append(random.choices(numbers, k=int(s)))
print('Insertion Sort\n')
for data in datas:
startTime = time_ns()
insertionSort(data)
endTime = time_ns()
executionTime = endTime - startTime
print(len(data), 'Datas ->', executionTime, 'nanoseconds')
times.append(executionTime / 1000000000)
plotSort(sizes, times, 'Insertion Sort')
times.clear()
print('\n\nMerge Sort\n')
for data in datas:
startTime = time_ns()
mergeSort(data, 0, len(data) - 1)
endTime = time_ns()
executionTime = endTime - startTime
print(len(data), 'Datas ->', executionTime, 'nanoseconds')
times.append(executionTime / 1000000000)
plotSort(sizes, times, 'Merge Sort')
def test_insertion_sort(self):
input = [10, 2, 13, 8, 16, 14]
output = [2, 8, 10, 13, 14, 16]
#insertionSort(input)
mergeSort(input, 0, 5)
self.assertListEqual(input, output)
def run(n):
data = sample(range(n + 1), n)
start_time = time_ns()
mergeSort(data, 0, n - 1)
end_time = time_ns()
time_taken = end_time - start_time
print(time_taken)
execution_time.append(time_taken)
def sortedHist(hist, minT=0):
"Actually returns a sorted list of (key, value) tuples"
tuples = hist.items()
if minT > 0:
tuples = filter(lambda kvtuple: kvtuple[1] > minT, tuples)
# True implies reverse=True, aka DESCENDING
return mergeSort(tuples, __hist_cmp, True)
def assignment2():
l = createRandomList(10)
l1 = l[:]
l2 = l[:]
l3 = l[:]
l4 = l[:]
ls = sorted(l)
sorting.quickSort(l1, 0, len(l1) - 1)
sorting.quickSort(l2, 0, len(l2) - 1, True)
sorting.mergeSort(l3)
sorting.countingSort(l4)
print("Unsorted: ", l)
print("Epected: ", ls)
print("After quick: ", l1)
print("After modified quick: ", l2)
print("after merge: ", l3)
print("after counting: ", l4)
def findMedian(lis): """ find the median of a sequence by simply sorting them and obtain the item in the cell with index at the middle. """ m=len(lis)//2 l=sorting.mergeSort(lis) return l[m] if len(l)%2!=0 else (l[m-1]+l[m])/2
def do_merge_sort(self):
if not self.start and not self.sorted:
self.start = True
self.bars = sorting.mergeSort(self.bars, self)
self.start = False
self.sorted = True
return True
else:
return False
def generar_tiempos(n):
lista_insertion = [random.random() for i in range(0, n)]
lista_selection = copy.deepcopy(lista_insertion)
lista_bubble = copy.deepcopy(lista_insertion)
lista_merge = copy.deepcopy(lista_insertion)
lista_quick = copy.deepcopy(lista_insertion)
tiempo_1 = time.process_time()
sorting.insertionSort(lista_insertion)
tiempo_2 = time.process_time()
sorting.selectionSort(lista_selection)
tiempo_3 = time.process_time()
sorting.bubbleSort(lista_bubble)
tiempo_4 = time.process_time()
sorting.mergeSort(lista_merge)
tiempo_5 = time.process_time()
sorting.quickSort(lista_quick)
tiempo_6 = time.process_time()
return np.asarray(
(n, tiempo_2 - tiempo_1, tiempo_3 - tiempo_2, tiempo_4 - tiempo_3,
tiempo_5 - tiempo_4, tiempo_6 - tiempo_5))
def main():
randomList = createRandomList(10)
randomList2 = randomList[:]
randomList3 = randomList[:]
randomList4 = randomList[:]
randomList5 = randomList[:]
expectedResult = sorted(randomList[:])
print("Generated list: ", randomList)
print("Expected result: ", expectedResult)
sorting.bubbleSort(randomList)
print("After Bubble sort: ", randomList)
sorting.selectionSort(randomList2)
print("After selection sort: ", randomList2)
sorting.shakerSort(randomList3)
print("After shaker sort: ", randomList3)
sorting.mergeSort(randomList4)
print("After merge sort: ", randomList4)
sorting.quickSort(randomList5, 0, len(randomList5) - 1)
print("After quick sort: ", randomList5)
def main():
if len(sys.argv) > 4:
problem = loadProblem(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4])
else:
filename = utils.getOpenFileName("problem.txt")
delimeter = utils.getDelimeter(",")
data_type = utils.getDataType("int")
problem = loadProblem(filename, delimeter, data_type)
comparisson_function = utils.getComparissonFunction("lambda x,y: x>y")
print("Sample items in the problem: %s" % problem[:10])
f = eval(comparisson_function)
insertion_sorted = sorting.insertionSort([x for x in problem], f)
merge_sorted = sorting.mergeSort([x for x in problem], f)
quick_sorted = sorting.quickSort([x for x in problem], f, 0, len(problem)-1)
print("insertion sorted: %s" % insertion_sorted)
print("merge sorted: %s" % merge_sorted)
def main():
number_of_random_tests = 100
size_of_problems = 5
filename = "test.txt"
f = lambda x,y: x>y
errors = {"insertion sort":0, "merge sort":0, "quick sort":0}
for _ in range(number_of_random_tests):
A = random.sample(range(size_of_problems), size_of_problems)
insertion_sort = sorting.insertionSort([x for x in A], f)
merge_sort = sorting.mergeSort([x for x in A], f)
quick_sort = [x for x in A]
sorting.quickSort(quick_sort, f, 0, len(A)-1)
testAlgo(A, insertion_sort, "insertion sort", errors, f)
testAlgo(A, merge_sort, "merge sort", errors, f)
testAlgo(A, quick_sort, "quick sort", errors, f)
print("errors: \n {}".format(errors))
def binarySearch(array, targval):
"""
Performs binary search.
"""
L, R = 0, len(array) - 1
while True:
m = (L+R) // 2
if array[m] < targval:
L = m + 1
continue
if array[m] > targval:
R = m - 1
continue
break
return m
userarray = input("Enter a series of numbers, divided by space, to have it "
"sorted, then have a binary search performed.\n")
userarray = userarray.split(" ")
for i in range(len(userarray)):
userarray[i] = int(userarray[i])
if len(userarray) > 1:
uservalue = int(input("\nNow enter a value to search its index.\n"))
userarray = mergeSort(userarray)
print("\nAfter sorting, first occurence of element " + str(uservalue) +
" has index of " + str(binarySearch(userarray, uservalue)) +
": " + str(userarray))
else:
print("Not enough elements in the array.\n")
input("Press Enter to close the program.")
from sorting import mergeSort
import matplotlib.pyplot as plt
n = 1000
mergeTimeArrayRandom = []
mergeTimeArrayBest = []
mergeTimeArrayWorst = []
sizeArr = []
for i in range(n, n * 11, n):
sizeArr.append(i)
randomValues = random.sample(range(i), i)
bestCase = randomValues
worstCase = randomValues
startTime = time()
mergeSort(randomValues)
endTime = time()
totalTime = endTime - startTime
mergeTimeArrayRandom.append(totalTime)
print("For", i, "the time is", totalTime)
bestCase.sort()
startTime = time()
mergeSort(bestCase)
endTime = time()
totalTime = endTime - startTime
mergeTimeArrayBest.append(totalTime)
print("For", i, "the time is", totalTime)
worstCase.sort(reverse=True)
startTime = time()
def test_merge_sort_descending(self):
"""
test the merge sort in descending order
"""
self.assertEqual(mergeSort(self.initA, False), self.decreasing)
def test4(self):
'''Test 4 checks that the merge sort can sort a list of 4 items reversed.
'''
inlist = [4,3,2,1]
outlist = [1,2,3,4]
assert (sorting.mergeSort(inlist)==outlist) #test 4 fails - list not sorted by merge sort.
def sortedSubstrHist(hist, minT=0):
tuples = hist.items()
if minT > 0:
tuples = filter(lambda kvtuple: kvtuple[1] > minT, tuples)
# True implies reverse=True, aka DESCENDING
return mergeSort(tuples, __substr_hist_cmp, True)
def test_merge_sort(self): arr=[6,1,0,3,8,2,4,7,5,9] sortedArr = [0,1,2,3,4,5,6,7,8,9] mergeSort(arr) self.assertListEqual(arr,sortedArr)
def test_merge_sort_ascending(self):
"""
test the merge sort in ascending order
"""
self.assertEqual(mergeSort(self.initA), self.increasing)
