def start():
global data
if var.get() == OptionList[0]:
bub_sort(data, drawdata, speed.get())
if var.get() == OptionList[1]:
mergeSort(data, 0, int(data_size.get()) - 1, drawdata, speed.get())
if var.get() == OptionList[2]:
insertionSort(data, drawdata, speed.get())
if var.get() == OptionList[3]:
quickSort(data, 0, int(data_size.get()) - 1, drawdata, speed.get())
def occurOnce(arr):
quickSort(arr, 0, len(arr))
frequency = 1
for i in range(1, len(arr)):
if arr[i] == arr[i - 1]:
frequency += 1
else:
if frequency == 1:
print(arr[i - 1])
else:
frequency = 1
if i == (len(arr) - 1):
print(arr[i])
def mostFrequent(arr):
quickSort(arr, 0, len(arr))
frequency = 1
freqCheck = 1
value = arr[0]
for i in range(1, len(arr)):
if arr[i] == arr[i - 1]:
freqCheck += 1
else:
if freqCheck >= frequency:
frequency = freqCheck
value = arr[i - 1]
freqCheck = 1
return [value, frequency]
def methodTester(sortMethod, baseSize=10):
#store the sorted file names
sorted_files = []
# Create the random number files
files = _fileCreator(baseSize)
# Create the time table file
timing_file = open(str(sortMethod) + "Sort_test_times", 'w')
timing_file.write("Input Size (n): Time cost:")
# For each of the files:
for file in files:
# Create a list from the numbers stored in the file
number_list = _fileToList(file)
number_count = len(number_list)
for i in range(number_count):
number_list[i] = float(number_list[i])
# Create the file to store the sorted list
sortedFileName = str(file) + "_" + sortMethod + "sort_sorted"
sorted_files.append(sortedFileName)
sortedFile = open(sortedFileName, 'w')
# Check sorting method, then sort while timing
if sortMethod == 'merge':
start_time = time.time()
numberListSorted = mSort.mergeSort(number_list, 1,
len(number_list))
stop_time = time.time()
elif sortMethod == 'quick':
start_time = time.time()
numberListSorted = qSort.quickSort(number_list, 0,
len(number_list) - 1)
stop_time = time.time()
elif sortMethod == 'insertion':
start_time = time.time()
numberListSorted = iSort.insertionSort(number_list,
len(number_list))
stop_time = time.time()
else:
print('''Uh oh, the provided sort method has yet to be implemented!
Please use either 'merge', 'quick', or 'insertion'.\n''')
# Store the sorted list in its respective file
sortedFile.write(str(numberListSorted))
sortedFile.close()
# Calculate the time taken, then add it to the timing file
sort_time = stop_time - start_time
timing_file.write("\n" + str(number_count) + " " + str(sort_time))
# Close the timing file, and prompt the user on whether
# or not to delete the created files used to calculate
# the timing data.
timing_file.close()
files.extend(sorted_files)
_askDelete(files)
def main():
# create a list of random integers between -100 and 100
myList = list(np.random.randint(-100, 100, 10))
print(f'Unsorted list:\t\t{myList}')
# create an object with which to sort, using the list as an input
sorter = quickSort(myList)
# print the sorted list
print(f'Sorted list:\t\t{sorter.sort()}')
def sorted_squares(nums):
result = []
for i in range(len(nums)):
sqr = nums[i]**2
if
i = 0
for i in range(len(result)):
if i = 0
array_len = len(result)
# result = quickSort(result,0, array_len-1)
return quickSort(result,0, array_len-1)
f.write("/nOriginal data:/n")
f.write(str(arr))
#使用python内置的timSort排序算法
a=arr[:]
print '/nStart internal sort...'
t1=time.clock()
a.sort()
t2=time.clock()
print 'Internal sort finisehd. Time used=%fs'%(t2-t1)
f.write('/n/nInternal sort [Time used=%fs]/n'%(t2-t1))
f.write(str(a))
del a
a=arr[:]
print '/nStart quick sort...'
t1=time.clock()
quick_sort.quickSort(a)
t2=time.clock()
print 'Quick sort finished. Time used=%fs'%(t2-t1)
f.write('/n/nQuick sort [Time used=%fs]/n'%(t2-t1))
f.write(str(a))
del a
a=arr[:]
print '/nStart heap sort...'
t1=time.clock()
heap_sort.heapSort(a)
t2=time.clock()
print 'Heap sort finished. Time used=%fs'%(t2-t1)
f.write('/n/nHeap sort [Time used=%fs]/n'%(t2-t1))
f.write(str(a))
del a
a=arr[:]
def test_random_list():
test_list = [8, 4, 23, 42, 16, 15]
expected = [4, 8, 15, 16, 23, 42]
quickSort(test_list, 0, len(test_list) - 1)
assert test_list == expected
from quick_sort import quickSort print(quickSort([10, 5, 2, 3]))
def kth_largest_element(array, k):
array = quickSort(array)
array.reverse()
return array[k - 1]
def testSort(tests, n, minimum, maximum):
time = [datetime.timedelta(0)] * 6
for i in range(tests):
ar = createArray(n, minimum, maximum)
i_sort = list(ar)
m_sort = list(ar)
q_sort = list(ar)
qr_sort = list(ar)
h_sort = list(ar)
d = datetime.datetime.now()
insertion_sort.insertionSort(i_sort)
time[0] += (datetime.datetime.now() - d)
d = datetime.datetime.now()
m_sort = merge_sort.mergeSort(m_sort)
time[1] += (datetime.datetime.now() - d)
d = datetime.datetime.now()
quick_sort.quickSort(q_sort)
time[2] += (datetime.datetime.now() - d)
d = datetime.datetime.now()
quick_sort.quickSortRand(qr_sort)
time[3] += (datetime.datetime.now() - d)
d = datetime.datetime.now()
h_sort = heap_sort.heapSort(h_sort)
time[4] += (datetime.datetime.now() - d)
d = datetime.datetime.now()
bible = sorted(ar)
time[5] += (datetime.datetime.now() - d)
error = False
if not compareArrays(bible, i_sort):
print "Insertion sort error: ar =", ar, ", i_sort =", i_sort, ", bible =", bible
error = True
if not compareArrays(bible, m_sort):
print "Merge sort error: ar =", ar, ", m_sort =", m_sort, ", bible =", bible
error = True
if not compareArrays(bible, q_sort):
print "Quick sort (deterministic) error: ar =", ar, ", q_sort =", q_sort, ", bible =", bible
error = True
if not compareArrays(bible, qr_sort):
print "Quick sort (random) error: ar =", ar, ", qr_sort =", qr_sort, ", bible =", bible
error = True
if not compareArrays(bible, h_sort):
print "Heap sort error: ar =", ar, ", h_sort =", h_sort, ", bible =", bible
error = True
if not error:
print "Test", i + 1, "successful"
print "Insertion sort time =", time[0]
print "Merge sort time =", time[1]
print "Quick sort (deterministic) time =", time[2]
print "Quick sort (random) time =", time[3]
print "Heap sort time =", time[4]
print "Default Python sort time =", time[5]
if __name__ == "__main__":
main()
A = vetor[1:]
# primeiro elemento da lista eh o tamanho da lista
n = vetor[0]
if opt == 'SS':
saida(selection_sort(A))
if opt == 'IS':
saida(insertion_sort(A))
if opt == 'HS':
saida(heapsort(A))
if opt == 'MS':
saida(topDownMergeSort(A))
if opt == 'QS':
saida(quickSort(A))
if opt == 'CS':
saida(counting_sort(A))
if opt == 'RS':
saida(radix_sort(A))
def test_big_input(self, rst, nums):
self.assertEqual(rst, quickSort(nums))
def test_basic(self, rst, nums):
self.assertEqual(rst, quickSort(nums))
def test_quickSort_array_last_val(self):
arr = self.test_create_array()
sorted_arr = quickSort(arr)
self.assertEqual(sorted_arr[3], 2)
#read in text files and call to three sum
import os
import glob
import quick_sort
import time
current_dir = os.getcwd()
data_dir = os.listdir('hw2-5.data')
os.chdir('hw2-5.data')
for x in range(0,1):
for file in data_dir:
input_list = []
print(file) #check current file we are reading
f = open(file, "r")
file_by_line = f.readlines()
for x in file_by_line:
input_list.append(x.strip()) #adding values from text file into an array
input_list = list(map(int, input_list)) #converting string to an integer
start_time = time.time()
quick_sort.quickSort(input_list)
elapsed_time = time.time() - start_time - 0.005
print(elapsed_time)
#print(input_list)
# algoritmos
start = time.time()
selection_sort(SS)
tempo['SS'] = (time.time() - start)*1000
start = time.time()
insertion_sort(IS)
tempo['IS'] = (time.time() - start)*1000
start = time.time()
heapsort(HS)
tempo['HS'] = (time.time() - start)*1000
start = time.time()
quickSort(QS)
tempo['QS'] = (time.time() - start)*1000
start = time.time()
topDownMergeSort(MS)
tempo['MS'] = (time.time() - start)*1000
start = time.time()
CS, menorValor = entrada_NegaToPosi(CS, n) # deixa lista totalmente positiva
CS = counting_sort(CS)
CS = entrada_PosiToNega(CS, menorValor, n) # retorna a lista com valores original
tempo['CS'] = (time.time() - start)*1000
start = time.time()
RS, menorValor = entrada_NegaToPosi(RS, n) # deixa lista totalmente positiva
RS = radix_sort(RS)
def test_couple_zeros():
test_list = [0, 0, 1, 1, 0]
expected = [0, 0, 0, 1, 1]
quickSort(test_list, 0, len(test_list) - 1)
assert test_list == expected
def test_nearly_sorted():
test_list = [2, 3, 5, 7, 13, 11]
expected = [2, 3, 5, 7, 11, 13]
quickSort(test_list, 0, len(test_list) - 1)
assert test_list == expected
def test_few_uniques():
test_list = [5, 12, 7, 5, 5, 7]
expected = [5, 5, 5, 7, 7, 12]
quickSort(test_list, 0, len(test_list) - 1)
assert test_list == expected
from quick_sort import quickSort from random import randint import time, copy A = [ randint(1,100) for i in range(1, 10000) ] A2 = copy.copy(A) start = time.time() quickSort(A,0,len(A)-1) end = time.time() print(end - start) start = time.time() A2.sort() end = time.time() print(end - start)
def test_quickSort_array(self):
arr = self.test_create_array()
sorted_arr = quickSort(arr)
self.assertEqual(sorted_arr[0], 1)
high = len(sorted_numbers)
while high >= low:
mid = (low + high) // 2
if integer == sorted_numbers[mid]:
return mid
elif integer < sorted_numbers[mid]:
high = mid - 1
else:
low = mid + 1
return -1
if __name__ == "__main__":
# Random number generation
print("Binary search algorithm")
limit = 10
rand_array = np.random.randint(0, 100, limit)
print("numbers")
print(rand_array)
# sort
quickSort(rand_array, 0, limit-1)
print("Sorted array")
print(rand_array)
# search
element = int(input("Enter the number to search: "))
index = binarySearch(rand_array, element)
if index != -1:
print(f"{element} found at index {index} in the sorted array.")
else:
print(f"{element} is not in the array.")
f.write("/nOriginal data:/n")
f.write(str(arr))
#使用python内置的timSort排序算法
a = arr[:]
print '/nStart internal sort...'
t1 = time.clock()
a.sort()
t2 = time.clock()
print 'Internal sort finisehd. Time used=%fs' % (t2 - t1)
f.write('/n/nInternal sort [Time used=%fs]/n' % (t2 - t1))
f.write(str(a))
del a
a = arr[:]
print '/nStart quick sort...'
t1 = time.clock()
quick_sort.quickSort(a)
t2 = time.clock()
print 'Quick sort finished. Time used=%fs' % (t2 - t1)
f.write('/n/nQuick sort [Time used=%fs]/n' % (t2 - t1))
f.write(str(a))
del a
a = arr[:]
print '/nStart heap sort...'
t1 = time.clock()
heap_sort.heapSort(a)
t2 = time.clock()
print 'Heap sort finished. Time used=%fs' % (t2 - t1)
f.write('/n/nHeap sort [Time used=%fs]/n' % (t2 - t1))
f.write(str(a))
del a
a = arr[:]
import quick_sort
# we will be searching using binary search but for that we need a sorted array
items = [2, 4, 1, 10, 13, 5, 6, 7, 8]
quick_sort.quickSort(items, 0, len(items) - 1)
def binarySearch(item, dataset):
# finding middle point
middle = (len(dataset) - 1) // 2
print(middle)
if item == dataset[middle]:
return middle
elif item > dataset[middle]:
return binarySearch(item, dataset[middle:])
elif item < dataset[middle]:
return binarySearch(item, dataset[:middle])
