def performOperation(list):
#while loop for perfoming operation on the linked list
performOperation=True
while performOperation==True:
print "select operation on linked list"
operation=int(raw_input("1 for seletion sort \n 2 for bubble sort \n 3 form insertion sort \n 4 for merge sort \n 5 for quick sort"))
#performing operation on the linked list according to user input
if operation==1:
print "selection sort operation"
selectionsort.selectionSort(list)
elif operation==2:
print "Bubble sort operation"
bublesSort.BubbleSort(list)
elif operation==3:
print "Insertion sort operation"
insertionSort.InsertionSort(list)
list.show()
elif operation==4:
print "Merge sort operation"
mergeSort.MargeSort(list.start())
list.show()
elif operation==5:
print "Quick sort operation"
quickSort.QuickSort(list.start(),list.last())
list.show()
else:
print "enter a valid option"
check=raw_input("\nenter y or Y perform other operation ")
if check!='y' and check!='Y':
performOperation=False
def startSort():
global arr
if algoCombo.get() == 'Bubble Sort':
bubbleSort(arr, displayArray, sortSpeed.get(), pauseBool)
elif algoCombo.get() == 'Selection Sort':
selectionSort(arr, displayArray, sortSpeed.get(), pauseBool)
elif algoCombo.get() == 'Merge Sort':
mergeSort(arr, displayArray, sortSpeed.get(), pauseBool, 0,
len(arr) - 1)
elif algoCombo.get() == 'Quick Sort':
quickSort(arr, displayArray, sortSpeed.get(), pauseBool, 0,
len(arr) - 1)
def StartAlgorithm():
global data
if not data: return
if algMenu.get() == 'Quick Sort':
quick_sort(data, 0, len(data)-1, drawData, speedScale.get())
drawData(data, ['green' for x in range(len(data))])
elif algMenu.get() == 'Bubble Sort':
bubble_sort(data, drawData, speedScale.get())
elif algMenu.get() == 'Selection Sort':
selectionSort(data, drawData, speedScale.get())
elif algMenu.get() == 'Insertion Sort':
insertionSort(data, drawData, speedScale.get())
elif algMenu.get() == 'Merge Sort':
merge_sort(data, drawData, speedScale.get())
drawData(data, ['green' for x in range(len(data))])
alist = buildArrFromFile("array_2M_range_1000.txt")
print("Please select a sorting algorithm\n")
print("1 - Selection sort\n")
print("2 - Insertion sort\n")
print("3 - Quick sort\n")
print("4 - Merge sort\n")
print("5 - Heap sort\n")
print("6 - Counting sort\n")
print("7 - Radix sort\n")
print("0 - Quit\n")
userSelection = input()
#Run the selected algorithm
if userSelection == '1':
startTime = time.time()
selectionsort.selectionSort(alist)
endTime = time.time()
resultsFile.write("You chose Selection sort\n")
elif userSelection == '2':
startTime = time.time()
insertionsort.insertionSort(alist)
endTime = time.time()
resultsFile.write("You chose Insertion sort\n")
elif userSelection == '3':
startTime = time.time()
alist = quicksort.quickSort(alist)
endTime = time.time()
resultsFile.write("You chose Quick sort\n")
elif userSelection == '4':
startTime = time.time()
mergesort.mergeSort(alist)
# for line in fp:
# arr.append(int(line.strip()))
start = time.process_time()
bubbleSort(arr)
end = time.process_time()
elapsed = (end - start) * (10**6)
print("Time for Bubblesort:")
print("%.3f" % (elapsed))
start = time.process_time()
merge_sort(arr)
end = time.process_time()
elapsed = (end - start) * (10**6)
print("Time for Mergesort:")
print("%.3f" % (elapsed))
start = time.process_time()
quickSort(arr)
end = time.process_time()
elapsed = (end - start) * (10**6)
print("Time for Quicksort:")
print("%.3f" % (elapsed))
start = time.process_time()
selectionSort(arr)
end = time.process_time()
elapsed = (end - start) * (10**6)
print("Time for Selectionsort:")
print("%.3f" % (elapsed))
def test_selectionSort():
mylist = [12, 34, 67, 45, 23, 36, 5, 17, 40, 10]
sorted_list = selectionSort(mylist)
assert sorted_list == [5, 10, 12, 17, 23, 34, 36, 40, 45, 67]
from selectionsort import selectionSort
from time import time
smallN = int(input("please enter smallest value of n: "))
largeN = int(input("please enter largest value of n: "))
numberOfM = int(input("please enter the number of test: "))
interval = (largeN - smallN) / numberOfM
numbers = []
times = []
while smallN <= largeN:
numbers.append(smallN)
values = []
for i in range(smallN):
values.append(randint(1, 100))
startTime = time()
selectionSort(values)
endTime = time()
ctime = endTime - startTime
times.append(ctime)
smallN = int(smallN + interval)
print("+--------+-------------+")
print("| number | times |")
print("+--------+-------------+")
for i in range(len(numbers)):
print("|%6d | %4.9f |" % (numbers[i], times[i]))
def main():
# List to sort
num_bars = DATA_SIZE[0] // (BAR_WIDTH + 1)
arr = [DATA_SIZE[1] // num_bars * i for i in range(1, num_bars)]
# Window layout
graph = sg.Graph(GRAPH_SIZE, (0, 0), DATA_SIZE, background_color='#F5F6F4')
layout = [[
sg.Text('Visualization',
size=(30, 1),
font=("Helvetica", 25),
background_color='#8F90A0',
text_color='#FFFFFF')
], [graph],
[
sg.Button('Select sorting method',
button_color=['#FFFFFF', '#35343B'],
font=("Helvetica", 12)),
sg.Button('Generate new array',
button_color=['#FFFFFF', '#35343B'],
font=("Helvetica", 12))
]]
window = sg.Window('Algorithm Visualizer', layout)
window.Finalize()
draw_bars(graph, arr)
while True:
event, values = window.read()
if event in (None, 'Exit'):
break
if event == 'Generate new array':
graph.Erase()
random.shuffle(arr)
draw_bars(graph, arr)
if event == 'Select sorting method':
l2 = [[
sg.T('Choose sorting method',
font=("Helvetica", 12),
background_color='#8F90A0',
text_color='#FFFFFF')
], [
sg.Listbox(['Bubble', 'Insertion', 'Selection'], size=(16, 3))
], [sg.Ok()]]
w2 = sg.Window('Choose sorting method', l2)
button, values = w2()
w2.close()
try:
if values[0][0] == 'Bubble':
sort = bubblesort.bubbleSort(arr)
sortmethod = 'Bubble'
elif values[0][0] == 'Insertion':
sort = insertionsort.insertionSort(arr)
sortmethod = 'Insertion'
else:
sort = selectionsort.selectionSort(arr)
sortmethod = 'Selection'
except:
sg.Popup('None selected.',
font=("Helvetica", 12),
background_color='#8F90A0',
text_color='#FFFFFF')
continue
timeout = 10
for partially_sorted_list in sort:
event, values = window.read(timeout=timeout)
if event is None:
break
graph.Erase()
draw_bars(graph, partially_sorted_list)
timeout = int(10)
sg.Popup(f'{sortmethod} sort done.',
font=("Helvetica", 12),
background_color='#8F90A0',
text_color='#FFFFFF')
def executeAlgos():
# yield 'Starting executeAlgos...\n'
shortSize = 10
popSize = shortSize * 10
shortData = random.sample(range(0, popSize), shortSize) # Generate Random data
copyShortData = copy.deepcopy(shortData) # Maintain a copy for other algorithms
print ("Generated random short data with %d elements\n"%shortSize)
print "short data = "+ str(shortData) + "\n"
stdout.flush()
# yield ("Generated random short data with %d elements"%shortSize)
# ------- SMALL DATASETS SORTING --------
# Merge sort : small dataset
startTime = datetime.datetime.now()
mergeSort(shortData)
endTime = datetime.datetime.now()
elapsedTime = endTime - startTime
print "Merge sorted short data = "+ str(shortData) + " in "+str(elapsedTime)+"\n"
stdout.flush()
# yield "\nMerge sorted short data = "+ str(shortData) + " in "+str(elapsedTime)
# Quick sort : small dataset
shortData = copy.deepcopy(copyShortData)
startTime = datetime.datetime.now()
quickSort(shortData)
endTime = datetime.datetime.now()
elapsedTime = endTime - startTime
print "Quick sorted short data = "+ str(shortData) + " in "+str(elapsedTime) + "\n"
stdout.flush()
# yield "\nQuick sorted short data = "+ str(shortData) + " in "+str(elapsedTime)
# Heap sort : small dataset
shortData = copy.deepcopy(copyShortData)
startTime = datetime.datetime.now()
heapSort(shortData)
endTime = datetime.datetime.now()
elapsedTime = endTime - startTime
print "Heap sorted short data = "+ str(shortData) + " in "+str(elapsedTime) + "\n"
stdout.flush()
# yield "\nQuick sorted short data = "+ str(shortData) + " in "+str(elapsedTime)
# Insertion sort : small dataset
shortData = copy.deepcopy(copyShortData)
startTime = datetime.datetime.now()
insertionSort(shortData)
endTime = datetime.datetime.now()
elapsedTime = endTime - startTime
print "Insertion sorted short data = "+ str(shortData) + " in "+str(elapsedTime)+ "\n"
stdout.flush()
# Selection sort : small dataset
shortData = copy.deepcopy(copyShortData)
startTime = datetime.datetime.now()
selectionSort(shortData)
endTime = datetime.datetime.now()
elapsedTime = endTime - startTime
print "Selection sorted short data = "+ str(shortData) + " in "+str(elapsedTime)+ "\n"
stdout.flush()
# -------- LARGE DATA -------
print '\n\n--------- Large data sets ---------\n\n'
largeSize = 10000 # Data set size for large data set demonstration
popSize = largeSize * 10 # Domain of random numbers allowed in random data set
largeData = random.sample(range(0, popSize), largeSize) # Genrate Random data
copyLargeData = copy.deepcopy(largeData) # Maintain a copy for other algorithms
print ("Generated random large data with %d elements\n"%largeSize)
# print "Large data = "+ str(largeData)+"\n"
stdout.flush()
# yield ("Generated random large data with %d elements"%largeSize)
# Merge sort : large dataset
print 'Merge sorting large data (%d elements)...\n' %( largeSize)
stdout.flush()
startTime = datetime.datetime.now()
mergeSortLargeData = copy.deepcopy(copyLargeData) # Maintain a copy for other algorithms
mergeSort(mergeSortLargeData)
endTime = datetime.datetime.now()
elapsedTime = endTime - startTime
print ("Merge sorted large data (%d elements) in "%( largeSize) + str(elapsedTime) ) + "\n"
stdout.flush()
# yield ("Merge sorted large data (%d elements) in "%( largeSize) + str(elapsedTime) )
# Quick sort : large dataset
print 'Quick sorting large data (%d elements)...\n' %( largeSize)
stdout.flush()
quickSortLargeData = copy.deepcopy(copyLargeData)
startTime = datetime.datetime.now()
quickSort(quickSortLargeData)
endTime = datetime.datetime.now()
elapsedTime = endTime - startTime
print ("Quick sorted large data (%d elements) in "%( largeSize) + str(elapsedTime)+ "\n" )
stdout.flush()
# yield ("Quick sorted large data (%d elements) in "%( largeSize) + str(elapsedTime) )
# Heap sort : large dataset
print 'Heap sorting large data (%d elements)...\n' %( largeSize)
stdout.flush()
heapSortLargeData = copy.deepcopy(copyLargeData)
startTime = datetime.datetime.now()
heapSort(heapSortLargeData)
endTime = datetime.datetime.now()
elapsedTime = endTime - startTime
print ("Heap sorted large data (%d elements) in "%( largeSize) + str(elapsedTime)+ "\n" )
stdout.flush()
# yield ("Quick sorted large data (%d elements) in "%( largeSize) + str(elapsedTime) )
# Insertion sort : large dataset
print 'Insertion sorting large data (%d elements)...\n' %( largeSize)
stdout.flush()
insertionSortLargeData = copy.deepcopy(copyLargeData)
startTime = datetime.datetime.now()
insertionSort(insertionSortLargeData)
endTime = datetime.datetime.now()
elapsedTime = endTime - startTime
print ("Insertion sorted large data (%d elements) in "%( largeSize) + str(elapsedTime)+ "\n" )
stdout.flush()
# Selection sort : large dataset
print 'Selection sorting large data (%d elements)...\n' %( largeSize)
stdout.flush()
largeSelectionSortData = copy.deepcopy(copyLargeData)
startTime = datetime.datetime.now()
selectionSort(largeSelectionSortData)
endTime = datetime.datetime.now()
elapsedTime = endTime - startTime
print ("Selection sorted large data (%d elements) in "%( largeSize) + str(elapsedTime) + "\n")
stdout.flush()
print "Printing large data sets...\n"
print "Raw large data set = "+ str(largeData)+"\n\n\n\n"
print "\n\n ------ Sorted Large Data sets ------\n\n"
print "Merge sorted large data = "+ str(mergeSortLargeData)+"\n\n\n\n"
print "Quick Sorted large data = "+ str(quickSortLargeData)+"\n\n\n\n"
print "Heap Sorted large data = "+ str(heapSortLargeData)+"\n\n\n\n"
print "Insertion Sorted large data = "+ str(insertionSortLargeData)+"\n\n\n\n"
print "Selection Sorted large data = "+ str(selectionSortLargeData)+"\n\n\n\n"
print '\nAlgorithms execution ended ...\n'
stdout.flush()
print("QuickSort ")
t1 = time.time()
qs.quickSort(ls, asc=True)
t2 = time.time()
print("Cres: ", (t2 - t1))
t1 = time.time()
qs.quickSort(ls, asc=False)
t2 = time.time()
print("Desc: ", (t2 - t1))
print("*******************************************")
print("BubbleSort ")
t1 = time.time()
bs.bubble_sort(ls, asc=True)
t2 = time.time()
print("Cres: ", (t2 - t1))
t1 = time.time()
bs.bubble_sort(ls, asc=False)
t2 = time.time()
print("Desc: ", (t2 - t1))
print("*******************************************")
print("SelectionSort ")
t1 = time.time()
ss.selectionSort(ls, asc=True)
t2 = time.time()
print("Cres: ", (t2 - t1))
t1 = time.time()
ss.selectionSort(ls, asc=False)
t2 = time.time()
print("Desc: ", (t2 - t1))
print("*******************************************")
