def sort_array(array, array_size, method='quick'):
if method == 'quick':
quick_sort(array, 0, array_size - 1)
elif method == 'heap':
heap_sort(array)
elif method == 'cocktail':
cocktail_sort(array)
def quick_vs_selec_vs_insr():
lista = []
for i in range(40000):
aleatorio = random.randint(0, 40000)
lista.append(aleatorio)
tempo = time.time()
quick_sort(lista, 0, len(lista) - 1)
fim = time.time()
print("[QUICKSORT] 40000 (40 mil) inteiros Aleatorios\n[TEMPO] "+ str(fim - tempo))
lista = []
for i in range(40000):
aleatorio = random.randint(0, 40000)
lista.append(aleatorio)
tempo = time.time()
selection_sort(lista, len(lista))
fim = time.time()
print("[SELECTIONSORT] 40000 (40 mil) inteiros Aleatorios\n[TEMPO] "+ str(fim - tempo))
lista = []
for i in range(40000):
aleatorio = random.randint(0, 40000)
lista.append(aleatorio)
tempo = time.time()
insertion_sort(lista, len(lista))
fim = time.time()
print("[INSERTIONSORT] 40000 (40 mil) inteiros Aleatorios\n[TEMPO] "+ str(fim - tempo))
print("\n")
def quicksort_vs_mergesort():
data = []
for i in range(4000000):
random_num = random.randint(0, 4000000)
data.append(random_num)
start = time.time()
quick_sort(data, 0, len(data) - 1)
end = time.time()
print(
"[QUICKSORT] 4000000 (4 million) integers random numbers \n [start] " +
str(end - start))
print("\n")
data = []
for i in range(4000000):
random_num = random.randint(0, 4000000)
data.append(random_num)
start = time.time()
merge_sort(data)
end = time.time()
print(
"[MERGESORT] 4000000 (4 million) integers random numbers \n [start] " +
str(end - start))
print("\n")
def assess(result):
quicksort.quick_sort(result)
tpr = 0
fpr = 0
for elem in result:
if elem[1] == 1:
tpr += 1
else:
fpr += 1
pos_area = 0
neg_area = 0
i = len(result) - 1
x = 0
y = 0
while i >= 0:
if result[i][1] == 1:
y += 1
else:
x += 1
pos_area += y / tpr
neg_area += 1 - y / tpr
i -= 1
print("pos_area:" + str(pos_area))
print("neg_area:" + str(neg_area))
return pos_area / (pos_area + neg_area)
def StartAlgorithm():
global data
speed = int(speedScale.get())
if speed == 2:
speed = 0.5
elif speed == 3:
speed = 0.1
elif speed == 4:
speed = 0.05
elif speed == 5:
speed = 0.01
elif speed == 6:
speed = 0.005
elif speed == 7:
speed = 0.001
if selected_algo.get() == "Bubble Sort":
bubble_sort(data, drawData, speed)
elif selected_algo.get() == "Selection Sort":
selection_sort(data, drawData, speed)
elif selected_algo.get() == "Insertion Sort":
insertion_sort(data, drawData, speed)
elif selected_algo.get() == "Merge Sort":
merge_sort(data, 0, len(data) - 1, drawData, speed)
drawData(data, ['light green' for x in range(len(data))])
time.sleep(speed)
elif selected_algo.get() == "Quick Sort":
quick_sort(data, drawData, speed)
def quicksort_vs_bubble():
lista = []
for i in range(40000):
random_num = random.randint(0, 40000)
lista.append(random_num)
start = time.time()
quick_sort(lista, 0, len(lista) - 1)
end = time.time()
print("[QUICKSORT] 40000 (40K) integers random numbers \n [TIME] " +
str(end - start))
lista = []
for i in range(40000):
random_num = random.randint(0, 40000)
lista.append(random_num)
start = time.time()
bubble_sort(lista, len(lista))
end = time.time()
print("[BUBBLESORT] 40000 (40K) integers random numbers \n [TIME] " +
str(end - start))
print("\n")
def StartAlgorithm():
global data
speed = int(speedScale.get())
if speed == 2:
speed = 1.5
elif speed == 3:
speed = 0.1
elif speed == 4:
speed = 0.05
elif speed == 5:
speed = 0.01
elif speed == 6:
speed = 0.005
elif speed == 7:
speed = 0.001
search = int(searchEntry.get())
if selected_algo.get() == "Bubble Sort":
bubble_sort(data, drawData, speed)
elif selected_algo.get() == "Selection Sort":
selection_sort(data, drawData, speed)
elif selected_algo.get() == "Insertion Sort":
insertion_sort(data, drawData, speed)
elif selected_algo.get() == "Merge Sort":
merge_sort(data, 0, len(data) - 1, drawData, speed)
drawData(data, ['light green' for x in range(len(data))])
time.sleep(speed)
elif selected_algo.get() == "Quick Sort":
quick_sort(data, drawData, speed)
elif algMenu.get() == 'Linear Search':
linear_search(data, search, drawData, speedScale.get())
elif algMenu.get() == 'Binary Search':
merge_sort(data, 0, len(data) - 1, drawData, speed)
drawData(data, ['red' for x in range(len(data))])
binary_search(data, search, drawData, speedScale.get())
def run_single_test(algorithm, list_type, list_size):
sort_list = get_list(list_type, list_size)
pr = cProfile.Profile()
pr.enable()
if algorithm == "merge_sort":
mergesort.merge_sort(sort_list, 0, len(sort_list) - 1)
elif algorithm == "quicksort":
quicksort.quick_sort(sort_list, 0, len(sort_list) - 1)
elif algorithm == "revised_quicksort":
revised_quicksort.revised_quick_sort(sort_list, 0,
len(sort_list) - 1, 50)
elif algorithm == "shell_sort":
shellsort.shell_sort(sort_list, get_shellsort_gaps(list_size))
pr.disable()
s = io.StringIO()
ps = pstats.Stats(pr, stream=s).sort_stats("cumulative")
ps.strip_dirs().print_stats()
results = s.getvalue()
for line in results.splitlines():
if "_sort)" in line:
print(line)
split_line = line.split()
return (split_line[4])
def main():
A = [12, 3, 5, 7, 4, 19, 26]
order = int(raw_input("Enter Order :"))
print RSelection(A, 0, len(A) - 1, order)
quicksort.quick_sort(A, 0, len(A) - 1)
print A
print A[order + 1]
def quick_insert_sort(A, p, r):
if p<r:
q = parition(A, p, r)
if q>k():
quick_sort(A, p, q-1)
quick_sort(A, q+1, r)
else:
insertion_sort(A)
return A
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())
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 test1():
data = []
for i in range(400000):
data.append(i)
start = time.time()
quick_sort(data, 0, len(data) - 1)
end = time.time()
print("[TEST] 400000 (400K) integers \ n [TIME] " + str(end - start))
print("\n")
def StartAlgorithm():
#print("Starting Algorithm .....")
global data
if not data:
return
if (algoMenu.get() == "Quick Sort"):
quick_sort(data, 0, len(data)-1, drawData, speedScale.get())
drawData(data, ['green' for x in range(len(data))])
elif (algoMenu.get() == 'Bubble Sort'):
bubble_sort(data, drawData, speedScale.get())
def teste3():
lista = []
for i in range(40000000):
lista.append(i)
tempo = time.time()
quick_sort(lista, 0, len(lista)-1)
fim = time.time()
print("[TESTE] 400000000 (40 milhoes) inteiros\n[TEMPO] "+ str(fim - tempo))
print("\n")
def startAlgo(): global list_numbers global selected_algo global speedscale global colorArray if selected_algo.get()==av_list[0]: bubble_sort(list_numbers,draw_in_canvas,float(speedscale.get()),colorArray) elif selected_algo.get()==av_list[1]: merge_sort(list_numbers,0, len(list_numbers)-1,draw_in_canvas,float(speedscale.get())) else: quick_sort(list_numbers,0,len(list_numbers)-1,draw_in_canvas,float(speedscale.get()))
def teste2():
lista = []
for i in range(400000):
random_num = random.randint(0, 400000)
lista.append(random_num)
tempo = time.time()
quick_sort(lista, 0, len(lista) - 1)
fim = time.time()
print("[TESTE] 400000 (400 mil) inteiros\n[TEMPO] " + str(fim - tempo))
print("\n")
def test1():
data = []
for i in range(40000):
random_num = random.randint(0, 40000)
data.append(random_num)
start = time.time()
quick_sort(data, 0, len(data) - 1)
end = time.time()
print("[TEST] 40,000 (40,000) integers \n [start] " + str(end - start))
print("\n")
def teste4():
lista = []
for i in range(40000000):
aleatorio = random.randint(0, 40000000)
lista.append(aleatorio)
tempo = time.time()
quick_sort(lista, 0, len(lista) - 1)
fim = time.time()
print("[TESTE] 40000000 (40 milhoes) inteiros\n[TEMPO] "+ str(fim - tempo))
print("\n")
def startalgorithm():
global data
if n.get() == "Bubble Sort":
bubblesort(data, speedy.get(), drawdata)
if n.get() == "Selection Sort":
selectionsort(data, speedy.get(), drawdata)
if n.get() == "Insertion Sort":
insertionsort(data, speedy.get(), drawdata)
if n.get() == "Merge Sort":
mergesort(data, speedy.get(), drawdata)
if n.get() == "Quick Sort":
quick_sort(data, drawdata, speedy.get())
def start_algo():
print("Starting Algorithm")
global data
ss = speedEntry.get()
ss = float(ss)
# ss = 0.1
if algMenu.get() == 'quick sort':
quick_sort(data, 0, len(data) - 1, drawData, ss)
elif algMenu.get() == 'Bubble sort':
bubble_sort(data, drawData, ss)
else:
merge_sort(data, drawData, ss)
def test3():
data = []
for i in range(40000000):
data.append(i)
start = time.time()
quick_sort(data, 0, len(data) - 1)
end = time.time()
print("[TEST] 400000000 (40 million) whole \ n [TIME] " +
str(end - start))
print("\n")
def test_quick_sort_string():
"""Test quick sort on a string."""
from quicksort import quick_sort
test_list = ['Joe', 'Jared', 'Mike']
lo = 0
hi = len(test_list) - 1
assert quick_sort(test_list, lo, hi) == ['Jared', 'Joe', 'Mike']
def test_quick_sort():
"""Test quick sort on random list."""
from quicksort import quick_sort
test_list = [0, 5, 6, 2, 4]
lo = 0
hi = len(test_list) - 1
assert quick_sort(test_list, lo, hi) == [0, 2, 4, 5, 6]
def test_quick_sort(self):
self.assertRaises(TypeError, quick_sort, (1, 2, 3))
self.assertRaises(TypeError, quick_sort, 1)
self.assertRaises(TypeError, quick_sort, 'helloworld!')
random.shuffle(self.seq)
self.seq = quick_sort(self.seq)
self.assertEqual(self.seq, range(self.N))
def test_quick_sort_rand_list():
"""test quick sort on random list."""
from quicksort import quick_sort
import random
x = random.sample(range(100), 10)
k = quick_sort(x)
x.sort()
assert k == x
def combo_type(self, combo):
if len(combo) == 1:
return "Single"
elif len(combo) == 2:
if len({card.name for card in combo}) == 1:
return "Pair"
return False
elif len(combo) == 3:
if len({card.name for card in combo}) == 1:
return "Triple"
return False
elif len(combo) == 5:
quicksort.quick_sort(combo, 0, 4)
if combo[0].name not in ("J", "Q", "K") and all(
(card_x.rank - 1) % 13 == card_y.rank % 13
for card_x, card_y in zip(combo, combo[1:])) and all(
card.suit == combo[0].suit for card in combo):
return "Straight Flush"
if combo[0].name not in ("J", "Q", "K") and all(
(card_x.rank - 1) % 13 == card_y.rank % 13
for card_x, card_y in zip(combo, combo[1:])):
return "Straight"
if all(card.suit == combo[0].suit for card in combo):
return "Flush"
if len({card.name for card in combo}) == 2:
if [card.name
for card in combo].count(combo[0].name) == 2 or 3:
return "Full House"
else:
return "Quad"
return False
else:
return False
def calc_freq(L):
'''
This function sorts the word list and increments the frequency of the words in the hashtable, creates a final unique word list and sorts it
:param: We pass the hashtable through as an argument
:precondition: The word_list and hashtable must exist with the respective words and values
:postcondition: The hashtable now contains the words with their respective frequencies and the word_list is also sorted, and a new unique sorted list is created
:return: Sorted word list and the hashtable
:complexity: Best Case = Worst Case = O(n), where n is the length of the list
'''
word_list, L = read_file(L)
final_word_list = []
for word in word_list:
L[word] += 1
if word not in final_word_list:
final_word_list.append(word)
quick_sort(final_word_list)
return final_word_list, L
def start_algo():
global data
if not data: return
if algoMenu.get() == 'Quick Sort':
quick_sort(data, 0, len(data) - 1, draw_Data, speedScale.get())
elif algoMenu.get() == 'Bubble sort':
bubble_sort(data, draw_Data, speedScale.get())
elif algoMenu.get() == 'Merge Sort':
merge_sort(data, draw_Data, speedScale.get())
elif algoMenu.get() == 'Insertion Sort':
insertion_sort(data, draw_Data, speedScale.get())
elif algoMenu.get() == 'Heap Sort':
heap_sort(data, draw_Data, speedScale.get())
draw_Data(data, ['green' for x in range(len(data))])
def startAlgorithm():
global data
if not data: return
if algMenu.get() == 'Quick Sort':
quick_sort(data, 0, len(data) - 1, drawData, speedScale.get())
elif algMenu.get() == 'Bubble Sort':
bubble_sort(data, drawData, speedScale.get())
elif algMenu.get() == 'Merge Sort':
merge_sort(data, drawData, speedScale.get())
elif algMenu.get() == 'Selection Sort':
selection_sort(data, drawData, speedScale.get())
elif algMenu.get() == 'Heap Sort':
heap_sort(data, drawData, speedScale.get())
elif algMenu.get() == 'Insertion Sort':
insertion_sort(data, drawData, speedScale.get())
elif algMenu.get() == 'Shell Sort':
shell_sort(data, drawData, speedScale.get())
drawData(data, ['green' for x in range(len(data))])
def quick_vs_selec_vs_insr():
data = []
for i in range(40000):
random_num = random.randint(0, 40000)
data.append(random_num)
start = time.time()
quick_sort(data, 0, len(data) - 1)
end = time.time()
print("[QUICKSORT] 40000 (40K) integers random numbers \n [start] " +
str(end - start))
print("\n")
data = []
for i in range(40000):
random_num = random.randint(0, 40000)
data.append(random_num)
start = time.time()
selection_sort(data, len(data))
end = time.time()
print("[SELECTIONSORT] 40000 (40 mil) integers random_nums\n[start] " +
str(end - start))
print("\n")
data = []
for i in range(40000):
random_num = random.randint(0, 40000)
data.append(random_num)
start = time.time()
insertion_sort(data, len(data))
end = time.time()
print("[INSERTIONSORT] 40000 (40 mil) integers random numbers \n[start] " +
str(end - start))
print("\n")
def quicksort_vs_mergesort():
lista = []
for i in range(4000000):
aleatorio = random.randint(0, 4000000)
lista.append(aleatorio)
tempo = time.time()
quick_sort(lista, 0, len(lista) - 1)
fim = time.time()
print("[QUICKSORT] 4000000 (4 milhoes) inteiros Aleatorios\n[TEMPO] "+ str(fim - tempo))
lista = []
for i in range(4000000):
aleatorio = random.randint(0, 4000000)
lista.append(aleatorio)
tempo = time.time()
merge_sort(lista)
fim = time.time()
print("[MERGESORT] 4000000 (4 milhoes) inteiros Aleatorios\n[TEMPO] "+ str(fim - tempo))
print("\n")
def quicksort_vs_bubble():
lista = []
for i in range(40000):
aleatorio = random.randint(0, 40000)
lista.append(aleatorio)
tempo = time.time()
quick_sort(lista, 0, len(lista) - 1)
fim = time.time()
print("[QUICKSORT] 40000 (40 mil) inteiros Aleatorios\n[TEMPO] "+ str(fim - tempo))
lista = []
for i in range(40000):
aleatorio = random.randint(0, 40000)
lista.append(aleatorio)
tempo = time.time()
bubble_sort(lista, len(lista))
fim = time.time()
print("[BUBBLESORT] 40000 (40 mil) inteiros Aleatorios\n[TEMPO] "+ str(fim - tempo))
print("\n")
def sort(filename,month):
"""
Given a csv file of interest and a month, this ranks the neighborhoods
based on their electricity and gas consumption.
"""
neighborhoods = determine_ranking(filename,month)
l=[]
for neighborhood in neighborhoods:
for key in neighborhood.keys():
l.append(round(key,10))
sorted_values = quicksort.quick_sort(l,0,len(l)-1)
rv = []
for value in sorted_values:
for neighborhood in neighborhoods:
for key in neighborhood.keys():
if value == round(key,10):
rv.append(neighborhood[key])
return rv
def sort(filename, month):
"""
Given a csv file of interest and a month, this ranks the neighborhoods
based on their electricity and gas consumption.
"""
neighborhoods = determine_ranking(filename, month)
l = []
for neighborhood in neighborhoods:
for key in neighborhood.keys():
l.append(round(key, 10))
sorted_values = quicksort.quick_sort(l, 0, len(l) - 1)
rv = []
for value in sorted_values:
for neighborhood in neighborhoods:
for key in neighborhood.keys():
if value == round(key, 10):
rv.append(neighborhood[key])
return rv
def sort_census(filename,month):
"""
Given a csv file of interest and a month, this ranks the neighborhoods
based on their electricity and gas consumption using a quicksort
algorithm.
"""
blocks = determine_census_ranking(filename,month)
l=[]
for key in blocks.keys():
l.append(round(key,10))
sorted_values = quicksort.quick_sort(l,0,len(l)-1)
rv = []
for value in sorted_values:
rv.append(blocks[value])
return rv
def main():
# a = [5,3,17,10,84,19,6,22,9]
# a = [13,11,9,12,12,4,9,4,21,2,6,11]
print("Quick-Insertion sort :", end=' ')
a = rand(100000)
# print_list(a)
start = time.clock()
a = quick_insert_sort(a, 0, len(a)-1)
end = time.clock()
# print_list(a)
print(end - start)
print("Quick sort :", end=' ')
a = rand(100000)
start = time.clock()
a = quick_sort(a, 0, len(a)-1)
end = time.clock()
print(end - start)
print("Insertion sort :", end=' ')
a = rand(100000)
start = time.clock()
insertion_sort(a)
end = time.clock()
print(end - start)
from quicksort import quick_sort
from version import Version
import re
T = int(raw_input())
versions = []
for x in xrange(0,T):
version = raw_input()
versions.append(Version.fromstring(version))
versions = quick_sort(versions)
print 'Sorted Versions:'
for x in versions:
print x
def test_ordered():
ordered = [0,1,2,3,4,5,6,7,8,9]
quick_sort(ordered)
for index, number in enumerate(ordered):
if index != 0:
assert number >= ordered[index-1]
def test_empty():
newarray = []
quick_sort(newarray)
assert len(newarray) == 0
def test_unordered():
unordered = [3,4,5,3,2,2,445,3,3,5,67,8,9,87,654,0,-50]
quick_sort(unordered)
for index, number in enumerate(unordered):
if index != 0:
assert number >= unordered[index-1]
def test_decending():
decending = [9,8,7,6,5,4,3,2,1]
quick_sort(decending)
for index, number in enumerate(decending):
if index != 0:
assert number >= decending[index-1]
output.append(item1)
p1 += 1
elif item2 < item1:
output.append(item2)
p2 += 1
else:
output.append(item1)
p1 += 1
p2 += 1
if p1 == len(list1):
output += list2[-(len(list2)-p2):]
elif p2 == len(list2):
output += list1[-(len(list1)-p2):]
return output
if __name__ == '__main__':
# list1 = input('Enter first list of items: ').split(',')
# list2 = input('Enter second list of items: ').split(',')
list1 = ['apple','damson','pear','orange','banana','plumb','carrot']
list2 = ['cat','zebra','frog','dog','mouse']
list1 = quick_sort(list1, 0, len(list1)-1)
list2 = quick_sort(list2, 0, len(list2)-1)
print(merge_sort(list1, list2))
else:
return binary_search(lst[:middle], key)
if __name__ == "__main__":
easy = [1,2,3,4,5,6,7,8]
print easy
for item in easy:
print binary_search(easy, item)
print
print binary_search(easy, 0)
print binary_search(easy, 100)
print "\n----------------\n"
even_length = [8,5,6,2,4,-10,3,100]
even_length = quicksort.quick_sort(even_length)
print even_length
for item in even_length:
print binary_search(even_length, item)
print
print binary_search(even_length, 0)
print binary_search(even_length, 1000)
print "\n----------------\n"
odd_length = [2.3, 1.1, 6.5, 3.2, 9.9]
odd_length = quicksort.quick_sort(odd_length)
print odd_length
for item in odd_length:
print binary_search(odd_length, item)
print
