def medicao_tempo(lista_de_entradas):
times = []
for entrada in lista_de_entradas:
print("\n\n", len(entrada), "Entradas \n\n")
sorters = [
BubbleSortPlus(entrada[:]),
BubbleSort(entrada[:]),
QuickSortPF(entrada[:]),
QuickSort(entrada[:]),
HeapSort(entrada[:]),
InsertionSort(entrada[:]),
MergeSort(entrada[:]),
SelectionSort(entrada[:]),
ShellSort(entrada[:])
]
#MEDINDO TEMPO DE ORDENAÇÃO
for sorter in sorters:
start = time.time()
sorter.sort()
end = time.time()
tempo = end - start
times.append([sorter.nome, len(entrada), tempo])
print("TEMPO", sorter.nome, len(entrada), "ENTRADAS:", tempo)
return times
def __init__(self, *args, **kwargs):
super(Test, self).__init__(*args, **kwargs)
#create a test list:
x = []
for i in range(300):
x.append(random.randint(-100, 100))
self.sorter = MergeSort.MergeSort(x, verbose=False)
def test_D(self):
"""sort of single element is the same element"""
#let's copy data
d = [1]
mysorter = MergeSort.MergeSort(d, verbose=False)
mysorter.sort()
self.assertEqual(mysorter.getData(), [1])
def runTest(fp):
'''
:param fp: file pointer to read in values
:return: number of right and the length of the linked list
creates linked lists and runs merge sort, then checks for correct result
'''
s_list = llist.LinkedList()
count = AddValues(s_list,fp)
s_list.head = student.MergeSort(s_list.head)
a_list = llist.LinkedList()
fp.seek(0,0)
AddValues(a_list,fp)
a_list.head = answer.MergeSort(a_list.head)
right = check(s_list, a_list)
# right = 0
# while s_list.head.next:
# if s_list.head <= s_list.head.next:
# right +=1
# s_list.head = s_list.head.next
return right, count
def test_C(self):
"""merging only changes start to end indexes"""
#let's copy data
d = [7, 9, 11, 23, 35, 8, 11, 22, 37, 81]
self.sorter = MergeSort.MergeSort(d, verbose=False)
dcopy = [7, 9, 11, 23, 35, 8, 11, 22, 37, 81]
self.sorter.merge(0, 4, 2)
for i in range(5, len(self.sorter.getData())):
self.assertTrue(self.sorter.getData()[i] == dcopy[i])
def test_sort(self):
"""tests if the sort works"""
x = []
for i in range(300):
x.append(random.randint(-100, 100))
self.sorter = MergeSort.MergeSort(x, verbose=False)
self.sorter.sort()
d = self.sorter.getData()
for el in range(0, len(d) - 2):
self.assertTrue(d[el] <= d[el + 1])
def MergeSortBest(self):
stop = False
N = 2
timerList = []
while stop is not True:
A = ArrayGen.SortedArray(N)
start = timer()
MergeSort.MergeSort(A, 0, len(A) - 1)
end = timer()
timerList.append((end - start))
if N > self.Nmax:
stop = True
N += 1
return timerList
def calculateKNN(data_set, testing_data, k):
correct = 0
for test_data in testing_data:
euclidean_distances = []
for i in range(len(data_set)):
e_obj = EuclidianObj(
_calculateEuclideanDistance(test_data, data_set[i]), i)
euclidean_distances.append(e_obj)
# euclidean_distances.sort(key=lambda c: EuclidianObj.distance, reverse=False) # replace with merge sort
euclidean_distances = MergeSort.MergeSort(euclidean_distances)
k_points = []
for i in range(k):
k_points.append(data_set[euclidean_distances[i].get_index()])
class_counts = [0, 0, 0]
for point in k_points:
point_class = point.get_class()
if 'Iris-setosa' in point_class:
class_counts[0] += 1
elif 'Iris-versicolor' in point_class:
class_counts[1] += 1
elif 'Iris-virginica' in point_class:
class_counts[2] += 1
print(class_counts)
max_value = sys.maxsize * -1
max_index = 0
for i in range(3):
if class_counts[i] > max_value:
max_value = class_counts[i]
max_index = i
predicted_class = 0
if max_index == 0:
predicted_class = 'Iris-setosa'
elif max_index == 1:
predicted_class = 'Iris-versicolor'
else:
predicted_class = 'Iris-virginica'
print("predicted class:", predicted_class, "actual class: ",
test_data.get_class())
if predicted_class in test_data.get_class():
correct += 1
print("KNN got ", correct, " out of ", len(testing_data))
return correct
def MergeSortWorst(self):
stop = False
N = 2
Navg = 10
timerList = []
while stop is not True:
avgTime = 0
for i in range(0, Navg):
A = ArrayGen.DecreasingArray(N)
start = timer()
MergeSort.MergeSort(A, 0, len(A) - 1)
end = timer()
avgTime += (end - start)
timerList.append((avgTime / Navg))
if N > self.Nmax:
stop = True
N += 1
return timerList
def main():
#inputList = [5, 7, 10, 4, 1, 6, 8, 3]
#inputList = [3,9,12,6]
#inputList = [3,18,6,12,9]
#inputList = [5,4,3,2,1]
inputList = [22, 41, 18, 9, 8, 7, 10]
outputList = []
print('\nA entrada é: ', inputList)
print('\nOrdenando com MergeSort...')
MS.MergeSort(inputList.copy(), 0, len(inputList) - 1)
print('\n\nA entrada é: ', inputList)
print('\nOrdenando com QuickSort...')
QS.QuickSort(inputList.copy(), 0, len(inputList) - 1)
M = Util.generateSorted(sizeList[i])
N = Util.generateReversed(sizeList[i])
O = Util.generateSmallRange(sizeList[i])
#listList = [L, M, N, O]
#listNames = ['Random', 'Sorted', 'Reversed', 'SmallRange']
listList = [L, M, O]
listNames = ['Random', 'Sorted', 'SmallRange']
timesList = [[], [], [], [], [], [], []]
for x in range(len(listList)):
#L = listList[x]
L = Util.generateList(sizeList[i])
A = QuickSort.QuickSort(L)
B = HeapSort.HeapSort(L)
C = InsertionSort.InsertionSort(L)
D = MergeSort.MergeSort(L)
E = PythonSorted.PythonSorted(L)
F = SelectionSort.SelectionSort(L)
G = RadixSort.RadixSort(L)
sortList = [A, B, C, D, E, F, G]
sortNames = [
'Quick', 'Heap', 'Insertion', 'Merge', 'Python', 'Selection',
'Radix'
]
#sortList = [C]
#sortNames = ['Insertion']
for j in range(len(sortList)):
Start = time.time()
for n in N:
data = []
for i in range(n):
data.append(random.randint(0, n * 10))
temp = "*" * 25 + "Input Size: " + str(n) + "*" * 25
print(temp)
outputString += temp + "\n\n"
print("Merge Sort: ")
print("Random Order")
runtime = 0
for i in range(repetition):
startTime = time.time()
print("Start: " + str(startTime))
mergeSort = MergeSort.MergeSort(MergeSort.ASC)
sortedData = mergeSort.mergeSort(data[:])
if n < 100:
print(data)
print(sortedData)
tempTime = time.time() - startTime
print("Iteration " + str(i) + " Runtime: " + str(tempTime))
runtime += tempTime
print("End: " + str(time.time()))
randomSortTime = runtime / repetition
print("Average Time Taken: " + str(randomSortTime))
print("Sorted Order")
runtime = 0
for i in range(repetition):
startTime = time.time()
from MergeSort import *
import sys
def AddValues(list_, fp):
'''
:param list_: linked list to add values to
:param fp: file pointer to read from
:return: None
'''
for num in fp:
list_.push_back( float(num))
if __name__ == '__main__':
fp = open(input("Please Enter File Name: "), "r")
list_ = LinkedList()
AddValues(list_, fp)
#print (list_)
list_.head = MergeSort(list_.head)
print(list_)
fp.close()
import TestHelper
import MergeSort
import QuickSort
import heapSort
from time import time
l = TestHelper.CreateRandomIntList(100000, 10, 9000000)
lc = list(l)
t0 = time()
qck = QuickSort.QuickSort(l)
t1 = time()
s = MergeSort.MergeSort(l)
t2 = time()
heapSort.heapSort(lc)
t3 = time()
print((l[99], s[99]))
print((l[99], qck[99]))
print((l[99], lc[99]))
print('function vers1 takes %f' % (t1 - t0))
print('function vers2 takes %f' % (t2 - t1))
print('function vers3 takes %f' % (t3 - t2))
def ClosestPair(points):
'''
points are list of points, i.e. list of list
should input at least two points
no duplicate x and y coordinates
'''
# first define two base cases
if len(points) == 3:
distance1 = pointDistance(points[0], points[1])
distance2 = pointDistance(points[1], points[2])
distance3 = pointDistance(points[0], points[2])
if distance1 < min(distance2, distance3):
return ([points[0], points[1]], distance1)
elif distance2 < min(distance1, distance3):
return ([points[1], points[2]], distance2)
else:
return ([points[0], points[2]], distance3)
elif len(points) == 2:
distance = pointDistance(points[0], points[1])
return (points, distance)
elif len(points) == 4:
distance1 = pointDistance(points[0], points[1])
distance2 = pointDistance(points[0], points[2])
distance3 = pointDistance(points[0], points[3])
distance4 = pointDistance(points[1], points[2])
distance5 = pointDistance(points[1], points[3])
distance6 = pointDistance(points[2], points[3])
if distance1 < min(distance2, distance3, distance4, distance5,
distance6):
return ([points[0], points[1]], distance1)
elif distance2 < min(distance1, distance3, distance4, distance5,
distance6):
return ([points[0], points[2]], distance2)
elif distance3 < min(distance1, distance2, distance4, distance5,
distance6):
return ([points[0], points[3]], distance3)
elif distance4 < min(distance1, distance2, distance3, distance5,
distance6):
return ([points[1], points[2]], distance4)
elif distance5 < min(distance1, distance2, distance3, distance4,
distance6):
return ([points[1], points[3]], distance5)
else:
return ([points[2], points[3]], distance6)
# start recursive calls
else:
split = int(len(points) / 2)
points1, dis1 = ClosestPair(points[:split])
points2, dis2 = ClosestPair(points[split:])
if dis1 < dis2:
minDistance = dis1
point1, point2 = points1
else:
minDistance = dis2
point1, point2 = points2
# split situation
Px = MergeSort.MergeSort([x[0] for x in points])
xMidPoint = Px[split - 1]
# sort points by y coordinates
Py = MergeSort2D.MergeSort2D(points, 1)
# filter out points whose x coordinates are in the range [xMidPoint - minDistance, xMidPoint + minDistance]
# note here length of Sy might be less than 8
Sy = [
point for point in Py if point[0] >= xMidPoint -
minDistance and point[0] <= xMidPoint + minDistance
]
iterLength = len(Sy)
bestDistance = minDistance
if iterLength > 8: #9
for i in range(iterLength - 8): # 0,1,
for j in range(1, 8): # 1,2,3,4,5,6,7
compDistance = pointDistance(Sy[i], Sy[i + j])
if compDistance < minDistance:
bestDistance = compDistance
point1 = Sy[i]
point2 = Sy[i + j]
return ([point1, point2], bestDistance)
else:
pointSplit, distanceSplit = ClosestPair(Sy)
if distanceSplit < bestDistance:
point1, point2 = pointSplit
return ([point1, point2], bestDistance)
def test_mergesort(self):
data4 = [10, 9, -1, 0, 4, 7, 8]
ret = data4
MergeSort(data4)
sorted(ret)
self.assertEqual(ret, data4)
# -----------------------------------------------------------# # MergeSort Algorithm # # # # (C) 2020, LABANI SAID, France # # # # @: [email protected] # # -----------------------------------------------------------# from MergeSort import * # Test the algorithm for list of numbers print('List: ', [1, -2, 10, 3, 5]) print('After MergeSort Algorithm', MergeSort([1, -2, 10, 3, 5])) # Test the algorithm for list of letters print('List: ', ['w', 'z', 'b', 'e', 's']) print('After MergeSort Algorithm', MergeSort(['w', 'h', 'b', 's', 'j', 'e']))
def test_empty(self):
"""sorting of empty list is empty"""
sorter = MergeSort.MergeSort([])
sorter.sort()
self.assertEqual(sorter.getData(), [])
import BubbleSort
import SelectSort
import InsertSort
import MergeSort
if __name__ == '__main__':
x = input('input list:\n')
y = x.split()
arr = []
for i in y:
arr.append(int(i))
arr = MergeSort.MergeSort(arr)
print('after bubble sort:\n')
for j in arr:
print(j, end=' ')
def test_A(self):
"""sort([10,20,30],[15,25,35]) == [10,15,20,25,30,35]"""
mySorter = MergeSort.MergeSort([10, 20, 30, 15, 25, 35], verbose=False)
mySorter.sort()
self.assertEqual(mySorter.getData(), [10, 15, 20, 25, 30, 35])
# coding=utf-8
import InsertSort
import MergeSort
import QuickSort
import BubbleSort
import HeapSort
import random
import os
if __name__ == "__main__":
os.system("cls")
arr = []
count = int(1e2)
for i in range(count):
arr.append(random.random())
print("开始对各个排序算法进行性能测试，测试用的数据量大小为{}个浮点数".format(count))
a = arr.copy()
QuickSort.QuickSort(a)
a = arr.copy()
MergeSort.MergeSort(a)
a = arr.copy()
HeapSort.HeapSort(a)
a = arr.copy()
InsertSort.InsertSort(a)
a = arr.copy()
BubbleSort.BubbleSort(a)
start = datetime.datetime.now()
arr10 = QuickSort(arr10, 0, N - 1)
quickSortTimings.append(str(datetime.datetime.now() - start))
start = datetime.datetime.now()
arr11 = QuickSort(arr11, 0, N - 1)
quickSortTimings.append(str(datetime.datetime.now() - start))
start = datetime.datetime.now()
arr12 = QuickSort(arr12, 0, N - 1)
quickSortTimings.append(str(datetime.datetime.now() - start))
sortingTimeTableArray.append(quickSortTimings)
# Merge sorted
print("Merge sorted - Random Best Case Worst Case")
mergeSortTimings = ["Merge Sort "]
start = datetime.datetime.now()
arr13 = MergeSort(arr13)
mergeSortTimings.append(str(datetime.datetime.now() - start))
start = datetime.datetime.now()
arr14 = MergeSort(arr14)
mergeSortTimings.append(str(datetime.datetime.now() - start))
start = datetime.datetime.now()
arr15 = MergeSort(arr15)
mergeSortTimings.append(str(datetime.datetime.now() - start))
sortingTimeTableArray.append(mergeSortTimings)
# Heap sorted
print("Heap sorted - Random Best Case Worst Case")
heapSortTimings = ["Heap Sort "]
start = datetime.datetime.now()
arr16 = HeapSort(arr16)
heapSortTimings.append(str(datetime.datetime.now() - start))
def test_TestOutputArray(self):
'''
Checks if array is sorted.
'''
output = MergeSort.MergeSort([1, 4, 2, 3])
self.assertEqual(output, [1, 2, 3, 4])
def test_CorrectInput(self):
'''
Checks if input is correct.
'''
output = MergeSort.MergeSort(123)
self.assertEqual(output, -1)
def main():
print("TEST")
node: Node = Node('A')
node.next = Node('B')
print(str(node))
print()
print("BUBBLE SORT")
arr = [10, 3, 5, 12, 20, 9]
BubbleSort(arr)
print(arr)
print()
print("MERGE SORT")
arr2 = [45, 12, 99, 69, 1, 13]
MergeSort(arr2)
print(arr2)
print()
print("QUICK SORT")
arr3 = [45, 12, 99, 69, 1, 13]
QuickSort(arr3)
print(arr3)
print()
print("BINARY SEARCH")
arr4 = [1,2,6,8,14]
#print(BinarySearchRecursive(arr4, 2, 0, len(arr) - 1))
print(BinarySearchIterative(arr4, 8))
print(BinarySearchRecursive(arr4, 2, 0, len(arr4) - 1))
print()
graph = {
'A': ['B', 'C', 'D', 'E'],
'B': ['A', 'C', 'G'],
'C': ['A', 'B', 'D'],
'D': ['A', 'C', 'E', 'H'],
'E': ['A', 'D', 'F'],
'F': ['E', 'G', 'H'],
'G': ['B', 'F'],
'H': ['D', 'F']
}
# put neighbors in a reverse order for now
graph2 = {
'A': ['E', 'D', 'C', 'B'],
'B': ['G', 'C', 'A'],
'C': ['D', 'B', 'A'],
'D': ['H', 'E', 'C', 'A'],
'E': ['F', 'D', 'A'],
'F': ['H', 'G', 'E'],
'G': ['F', 'B'],
'H': ['F', 'D']
}
print("BREADTH FIRST SEARCH")
bfs(graph, 'A')
print()
print("DEPTH FIRST SEARCH")
dfs(graph2, 'A')
print()
if num != "X":
LI.append(int(num))
else:
terminate = True
print "\nThe Entered List is: ", LI
print "\nPlease Choose any one of the following Sorting Algorithms: \n1.Bubble Sort \n2.Selection Sort \n3.Insertion Sort \n4.Quick Sort \n5.Merge Sort"
choice = int(raw_input(">>"))
if choice == 1:
print "\nSorting the List using Bubble Sort..."
BubbleSort.BubbleSort(LI)
elif choice == 2:
print "\nSorting the List using Selection Sort..."
SelectionSort.SelectionSort(LI)
elif choice == 3:
print "\nSorting the List using Insertion Sort..."
InsertionSort.InsertionSort(LI)
elif choice == 4:
print "\nSorting the List using Quick Sort..."
QuickSort.QuickSort(LI)
elif choice == 5:
print "\nSorting the List using Merge Sort..."
MergeSort.MergeSort(LI)
else:
print "\nSorry Wrong Selection!!!"
print "BYE!!!"
exit()
print "\nThe Sorted List is : ", LI, "\n"
