def main(): setup() screen = s.screen isStart = False done = False while not done: for event in pygame.event.get(): if event.type == pygame.QUIT: done = True if event.type == pygame.KEYDOWN: if event.key == pygame.K_RIGHT: s.array.clear() s.numColor.clear() setup() if event.key == pygame.K_q: isStart = True sortType = 0 if event.key == pygame.K_b: isStart = True sortType = 1 screen.fill(s.Colors[0]) if not isStart: s.drawScreen() else: if sortType == 0: quick.quickSort(s.array, 0, len(s.array) - 1) if sortType == 1: bubble.bubbleSort(s.array) pygame.display.flip() pygame.quit()
def main(): toSort = list(range(0, 21)) fyShuffle(toSort) bubbleSort(toSort) fyShuffle(toSort) insertionSort(toSort) fyShuffle(toSort) mergeSort(toSort) fyShuffle(toSort) quickSort(toSort) fyShuffle(toSort) selectionSort(toSort) toSearch = [-16, -8, -4, -2, -1, 0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096] for i in range (0, len(toSearch)): binarySearch(toSearch, toSearch[i] - 1) binarySearch(toSearch, toSearch[i]) binarySearch(toSearch, toSearch[i] + 1) for i in range (0, len(toSearch)): interpolationSearch(toSearch, toSearch[i] - 1) interpolationSearch(toSearch, toSearch[i]) interpolationSearch(toSearch, toSearch[i] + 1) toSearch = [-10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10] for i in range (0, len(toSearch)): binarySearch(toSearch, toSearch[i] - 1) binarySearch(toSearch, toSearch[i]) for i in range (0, len(toSearch)): interpolationSearch(toSearch, toSearch[i] - 1) interpolationSearch(toSearch, toSearch[i])
def startAlgorithm(): global data disableWidgets() if algMenu.get()=='Bubble Sort': bubbleSort(data, drawData, speedScale.get()) elif algMenu.get() == 'Merge Sort': merge_sort(data, drawData, speedScale.get()) elif algMenu.get() == 'Quick Sort': quick_sort(data, 0, len(data)-1, drawData, speedScale.get()) drawData(data, ['green' for x in range(len(data))])
def startAlgorithm(): global data #check which algorithm is selected if algoMenu.get() == 'Bubble Sort': bubbleSort(data, draw, speed.get()) elif algoMenu.get() == 'Merge Sort': mergeSort(data, draw, speed.get()) elif algoMenu.get() == 'Selection Sort': selectionSort(data, draw, speed.get()) elif algoMenu.get() == 'Insertion Sort': insertionSort(data, draw, speed.get()) elif algoMenu.get() == 'Quick Sort': quick_sort(data, 0, len(data) - 1, draw, speed.get()) draw(data, ['green' for x in range(len(data))])
def checkInputs(n, array): if n == len(array) and len(array) > 1: array = [int(array[i]) for i in range(len(array))] removeDups = list(set(array)) sortArray = bubbleSort(removeDups) return sortArray[len(sortArray) - 2] else: return "please enter correct values"
def startAlgorithm(): global data if not data: return if(algMenu.get() == 'Bubble Sort'): bubbleSort(data, drawData, speedScale.get()) elif(algMenu.get() == 'Quick Sort'): quickSort(data, drawData, speedScale.get()) drawData(data, ['green' for x in range(len(data))]) elif(algMenu.get() == 'Insertion Sort'): insertionSort(data, drawData, speedScale.get()) elif(algMenu.get() == 'Selection Sort'): selectionSort(data, drawData, speedScale.get()) elif (algMenu.get() == 'Heap Sort'): heapSort(data, drawData, speedScale.get()) elif (algMenu.get() == 'Merge Sort'): mergeSort(data, drawData, speedScale.get()) drawData(data, ['green' for x in range(len(data))])
def get_sort(): restemp = [] if (request.json and request.json['array'] and isinstance(request.json['array'], list) and len(request.json['array']) > 0 and len(request.json['array']) <= 10 and isinstance(request.json['array'][0], int) and request.json['method'] and request.json['method'] in ['bubble', 'merge'] and isinstance(request.json['asc'], bool)): if (request.json['method'] == 'bubble'): bubbleSort.bubbleSort(restemp, request.json['array'], request.json['asc']) else: mergeSort.mergeSort(restemp, request.json['array'], request.json['asc']) return jsonify({'res': restemp}) else: return jsonify( {'res': 'Input is not valid, please input 1 up to 10 numbers'})
def sorting(): """Выбор сортировки из выпадающего списка""" global array sorting_speed = 0.2 #задаем скорость демонстрации в диапазоне от 0.1 до 1 if (selected_algorithm.get() == "Сортировка пузырьком"): bubbleSort(array, demoArray, sorting_speed) demoArray(array, ['#77E596' for element in range(len(array))]) elif (selected_algorithm.get() == "Сортировка вставками"): insertSort(array, demoArray, sorting_speed) demoArray(array, ['#77E596' for element in range(len(array))]) elif (selected_algorithm.get() == "Сортировка выбором"): selectSort(array, demoArray, sorting_speed) demoArray(array, ['#77E596' for element in range(len(array))]) elif (selected_algorithm.get() == "Сортировка слиянием"): mergeSort(array, 0, len(array) - 1, demoArray, sorting_speed) demoArray(array, ['#77E596' for element in range(len(array))]) elif (selected_algorithm.get() == "Быстрая сортировка"): quickSort(array, 0, len(array) - 1, demoArray, sorting_speed) demoArray(array, ['#77E596' for element in range(len(array))]) elif (selected_algorithm.get() == "Сортировка Шелла"): shellSort(array, demoArray, sorting_speed) demoArray(array, ['#77E596' for element in range(len(array))])
def main(): # array original array = [5, 4, 6, 2, 1, 7, 0, 3, 8, 9] # resultados array_select = selectSort(array) array_bubble = bubbleSort(array) # gabarito gabarito = array.copy() gabarito.sort() # saidas print("Array Original: ", array) print("Array Select: ", array_select) print("Array Bubble: ", array_bubble) print("Array Gabarito: ", gabarito)
def timeElapsed(algoritmo, arr): start_time = time.time() comparaciones = 0 if(algoritmo == "merge"): comparaciones = mergeSort.mergeSort(arr) elif(algoritmo == "quickStatic"): comparaciones = quickSortStaticPiv.quickSort(arr) elif(algoritmo == "quickAle"): comparaciones = quickSortRandomPiv.quickSort(arr) elif(algoritmo == "heap"): comparaciones = heapSort.heapSort(arr) elif(algoritmo == "bubble"): comparaciones = bubbleSort.bubbleSort(arr) elapsed_time = time.time() - start_time print("TamList: ", len(arr), "\tTime: ", elapsed_time, "Comps: ", comparaciones)
def sortAlgo(): global boo global array global barRec global epochs epochs = [0] boo = True try: size = int(sizeEntry.get()) except: size = 15 if size < 0: size = 1 #change the value of the speed selected s = 1001 - speed.get() #decide the algo if algDropDown.get() == "Merge Sort": algo = mergeSort(array, 0, size - 1) elif algDropDown.get() == "Bubble Sort": algo = bubbleSort(array) elif algDropDown.get() == "Quick Sort": algo = quickSort(array, 0, size - 1) elif algDropDown.get() == "Insertion Sort": algo = insertionSort(array) elif algDropDown.get() == "Selection Sort": algo = selectionSort(array) elif algDropDown.get() == "Heap Sort": algo = heapSort(array) elif algDropDown.get() == "Radix Sort": algo = radixSort(array) #start animation anima = anim.FuncAnimation(fig, func=updatePlot, fargs=(barRec, epochs), frames=algo, interval=s, repeat=False, blit=False) anima._start()
def test_unsorted_array(self): input = [1, 5, 63, 3, 54, 1] self.assertEqual(bubbleSort(input), sorted(input), "Should be [1, 1, 3, 5, 54, 63]")
def test_empty_array(self): input = [] self.assertEqual(bubbleSort(input), sorted(input), "Should be []")
lista = [] for i in range(tam): lista.append(i) random.shuffle(lista) return lista def geraListaReversa(tam): lista = [] for i in range(tam): lista.append(i) lista.reverse() return lista ''' vet = bubbleSort([7, 6, 5, 4, 3, 2, 1]) print(vet.vet) #print(vet.stats.swaps) vet.sort() print(vet.vet) #print(vet.stats.swaps) ''' intervals = [100, 200, 300, 400, 500] vectMelhor = bubbleSort(geraListaOrdenada(500), intervals) vectPior = bubbleSort(geraListaReversa(500), intervals) vect = bubbleSort(geraLista(500), intervals) E1 = Experiment([vect, vectMelhor, vectPior], intervals, title="Bubble Sort") E1.calculaTempos(bubbleSort) E1.plotar() x = 1
for j in range(0, n): arr.append(random.randrange(0, 1000, 1)) start_time = time.time() array = quickSort.quicksort(arr, 0, len(arr) - 1) print("The quick sorted array with size ", len(array), "is ") for i in range(0, len(array)): print("array[", i, "] = ", array[i]) end_time = time.time() quick_sort_time = end_time - start_time print("Quick sort time for size", n, "is ", quick_sort_time) arr.clear() for j in range(0, n): arr.append(random.randrange(0, 1000, 1)) start_time = time.time() array = bubbleSort.bubbleSort(arr) print("The bubble sorted array with size ", len(array), "is ") for i in range(0, len(array)): print("array[", i, "] = ", array[i]) end_time = time.time() bubble_sort_time = end_time - start_time print("Bubble sort time for size", n, "is ", bubble_sort_time) arr.clear() for j in range(0, n): arr.append(random.randrange(0, 1000, 1)) start_time = time.time() array = heapSort.heapSort(arr) print("The Heap sorted array with size ", len(array), "is ") for i in range(0, len(array)): print("array[", i, "] = ", array[i])
def test_emptyList(self): emptyList = [] expectedList = [] self.assertEqual(bubbleSort.bubbleSort(emptyList), expectedList)
def test_case1(self): test1 = [5, 2, 1, 3, 4] output = bubbleSort(test1) self.assertEqual(output, [1, 2, 3, 4, 5])
def testBubbleSort(self): A = [5, 1, 3, 0, 10] bubbleSort.bubbleSort(A) B = [0, 1, 3, 5, 10] if (A != B): self.fail("bubbleSort method fails.")
x1, y1 = [], [] x2, y2 = [], [] x3, y3 = [], [] x4, y4 = [], [] for scale in range(10, 5000+step, step): print(scale, end = "\r") s = np.random.randint(0,50,(scale)) start = time.time() _ = quickSort(s) end = time.time() x1.append(scale) y1.append(end-start) start = time.time() _ = bubbleSort(s) end = time.time() x2.append(scale) y2.append(end-start) start = time.time() _ = insertSort(s) end = time.time() x3.append(scale) y3.append(end-start) start = time.time() _ = selectSort(s) end = time.time() x4.append(scale) y4.append(end-start)
import bubbleSort as st testList = [5, 4, 3, 6, 10, 1, 2, 3] print(st.bubbleSort(testList))
def test_basicSort(self): unsortedList = [3, 2, 1] expectedList = [1, 2, 3] self.assertEqual(bubbleSort.bubbleSort(unsortedList), expectedList)
def test_negative(self): unsortedList = [-1, -2, -3] expectedList = [-3, -2, -1] self.assertEqual(bubbleSort.bubbleSort(unsortedList), expectedList)
def test_sortCharacters(self): unsortedList = ['b', 'a', 'c'] expectedList = ['a', 'b', 'c'] self.assertEqual(bubbleSort.bubbleSort(unsortedList), expectedList)
def test_backwards_array(self): input = [5, 4, 3, 2, 1] self.assertEqual(bubbleSort(input), sorted(input), "Should be [1, 2, 3, 4, 5]")
def main(): window.fill((255, 255, 255)) query = [random.randrange(20, 400) for i in range(100)] c = [135, 206, 235] start = 100 i = start j = 0 while i < 1000 + start: pygame.draw.line(window, c, (i, 500), (i, 500 - query[j]), 5) j += 1 i += 10 pygame.display.update() s = 80 quick = button(mnt, 10 + s, 520, 180, 50, "quickSort") button.draw(quick, window) merge = button(mnt, 210 + s, 520, 180, 50, "mergeSort") button.draw(merge, window) selection = button(mnt, 400 + s, 520, 200, 50, "selectionSort") button.draw(selection, window) insertion = button(mnt, 610 + s, 520, 200, 50, "insertionSort") button.draw(insertion, window) bubble = button(mnt, 820 + s, 520, 200, 50, "bubbleSort") button.draw(bubble, window) speed = Slider("Speed", 0.025, 0.05, 0, 630) pygame.display.update() pause = button(mnt, 450, 520, 160, 50, "start/stop") run = True while run: for event in pygame.event.get(): if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: pos = pygame.mouse.get_pos() if quick.isOver(pos): clearinstruction(window, pause) #message("illustrating ..quickSort",window) quickSort(query, 0, 99, window, pause, speed, 0.025) run = False elif merge.isOver(pos): clearinstruction(window, pause) #message("illustrating ..mergeSort",window) mergeSort(query, 0, 99, window, pause, speed) run = False elif selection.isOver(pos): clearinstruction( window, pause) #message("illustrating ..selectionSort",window) selectionSort(query, 0, 99, window, pause, speed) run = False elif insertion.isOver(pos): clearinstruction( window, pause) #message("illustrating ..insertionSort",window) insertionSort(query, 0, 99, window, pause, speed) run = False elif bubble.isOver(pos): #message("illustrating ..bubbleSort",window) clearinstruction(window, pause) bubbleSort(query, window, pause, speed) run = False elif event.type == pygame.QUIT: pygame.quit() clearInstruction(window) restart = button(mnt, 550, 520, 120, 50, "restart") button.draw(restart, window) pygame.display.update() run = True while run: for event in pygame.event.get(): if event.type == pygame.QUIT: run = False break if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1 and restart.isOver( pygame.mouse.get_pos()): try: main() except: pass pygame.quit()
def test_already_sorted(self): input = [0, 1, 2, 3, 4, 5] self.assertEqual(bubbleSort(input), sorted(input), "Should be [0,1,2,3,4,5]")
if (courseDays[i][j] == "M"): monday.append(i) elif (courseDays[i][j] == "W"): wednesday.append(i) elif (courseDays[i][j] == "F"): friday.append(i) elif (courseDays[i][j] == "T"): if (j + 1 > len(courseDays[i])): tuesday.append(i) elif (j + 1 < len(courseDays[i]) and courseDays[i][j + 1] == "T"): tuesday.append(i) elif (j + 1 < len(courseDays[i]) and courseDays[i][j + 1] == "H"): thursday.append(i) print len(monday) dayLabel = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"] day = [monday, tuesday, wednesday, thursday, friday] #Sort Classes By Time bubbleSort.bubbleSort(day, courseTimesValue) #Print Classes for i in range(0, len(day)): print(dayLabel[i]) print("_________________________") for j in range(0, len(day[i])): index = day[i][j] print(courseDepartment[index] + " " + str(courseNumber[index]) + " " + str(courseSection[index]) + " " + courseDays[index] + " " + courseTimes[index]) print("\n")
from bubbleSort import bubbleSort arr = [4, 3, 22, 3, 431, 1] print(arr) print(bubbleSort(arr)) print(arr)
import bubbleSort class binarySearch(object): def __init__(self, x, d): self.x = x self.d = d def binarySearch(self): lower = 0 upper = len(self.x) - 1 while lower <= upper: mid = (lower + upper) // 2 if self.x[mid] < self.d: lower = mid + 1 elif self.x[mid] > self.d: upper = mid - 1 else: return mid return -1 if __name__ == '__main__': x = [3, 20, 9, 15, 2] bubbleSortAg = bubbleSort.bubbleSort(x) xSort = bubbleSortAg.bubbleSort() d = 15 binarySearchAg = binarySearch(xSort, d) print(xSort) print(binarySearchAg.binarySearch())
import bubbleSort import selectionSort import insertSort import shellSort import mergeSort list = [2, 5, 60, 43, 27, 10, 89, 17] print('\nData yang akan di sort :\n', list) print('\nBubble Sort :\n') bubbleSort.bubbleSort(list) print("\n==================================================\n") print('\nSelection Sort :\n') selectionSort.selectionSort(list) print("\n==================================================\n") print('\nInsert Sort :\n') insertSort.insertionSort(list) print("\n==================================================\n") sublist = len(list) shellSort.shellSort(list) print("\nShell Sort :\n") for i in range(sublist): print(list[i]) print("\n==================================================\n") print('\nMerge Sort :\n') mergeSort.mergeSort(list) print("\n==================================================\n")
def test_alreadySorted(self): sortedList = [1, 2, 3] expectedList = [1, 2, 3] self.assertEqual(bubbleSort.bubbleSort(sortedList), expectedList)