def testcase(index, input_array, expected_output): print("\n-- testcase {} --".format(index)) input_array_copy = input_array print("input array : {}".format(input_array)) print("expected output : {}\n".format(expected_output)) # bst sort bst_sort_result = bst_sort(input_array) print("bst sort: {}, {}".format(bst_sort_result, bst_sort_result == expected_output)) # merge sort merge_sort_result = merge_sort(input_array) print("merge sort: {}, {}".format(merge_sort_result, merge_sort_result == expected_output)) # quick sort quick_sort(input_array, 0, len(input_array) - 1) print("quick sort: {}, {}".format(input_array, input_array == expected_output)) input_array = input_array_copy # heap sort heap_sort_result = heap_sort(input_array) print("heap sort: {}, {}".format(heap_sort_result, heap_sort_result == expected_output))
def test_quick_sort(self): p = 0 for array in self.arrays: r = len(array) - 1 quick_sort(array, p, r) self.check_sorting()
def pair_fin(clos_app,dt, aa, src, freq,fbmamp,multweight=True,noiseweight=True,ovlpweight=True,cutoff=9000.*0.005*0.005,puv=False): final = [] cnt, N = 0,len(clos_app) bm_intpl = export_beam.beam_interpol(freq,fbmamp,'cubic') if ovlpweight: #rbm2interp: FT of sq of beam fbm2 = n.multiply(fbmamp,fbmamp) #element wise square for power beam rbm2 = n.fft.fft2(fbm2); rbm2 = n.fft.fftshift(rbm2) freqlm = n.fft.fftfreq(len(freq),d=(freq[1]-freq[0])); freqlm = n.fft.fftshift(freqlm) print "###small imaginary components are error, nothing to worry about" rbm2interp = interpolate.interp2d(freqlm, freqlm, rbm2, kind='cubic') for key in clos_app: cnt = cnt+1 if (cnt/1000)*1000 == cnt: print 'Calculating baseline pair %d out of %d:' % (cnt,N) bl1,bl2 = key[0],key[1] t1,t2 = clos_app[key][1],clos_app[key][2] correlation,(uvw1,uvw2) = get_corr(aa, src, bm_intpl, t1,t2, bl1, bl2) if correlation == 0: continue if ovlpweight: ovlp = get_ovlp(aa,t1,t2,rbm2interp) else: ovlp = 1. weight = get_weight(aa,bl1,bl2,uvw1,multweight,noiseweight,ovlp) #while correlation > cutoff: if puv: final.append((weight*correlation,correlation,(bl1,t1,uvw1),(bl2,t2,uvw2))) else: final.append((weight*correlation,correlation,(bl1,t1),(bl2,t2))) #t1,t2 = t1+dt,t2+dt try: correlation,(uvw1,uvw2) = get_corr(aa, src,bm_intpl, t1,t2, bl1, bl2) except(TypeError): correlation = 0. else: if ovlpweight: ovlp = get_ovlp(aa,t1,t2,rbm2interp) else: ovlp = 1. weight = get_weight(aa,bl1,bl2,uvw1,multweight,noiseweight,ovlp) quick_sort.quick_sort(final,0,len(final)-1) return final
def testQuick(self): result = copy(self.original) before = time.time() quick_sort(result) after = time.time() print("Quick Sort, size: %d time: %f" % (self.list_length, after-before)) self.assertEqual(self.sorted_list, result, "Quick Sort Failed")
def test_quick_sort(): case_1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] case_2 = list(case_1) case_2.reverse() expected = list(case_1) assert quick_sort(case_1) == expected assert quick_sort(case_2) == expected
def test_quick_sort(self): arr = [8, 2, 4, 5, 7, 1] quick_sort(arr) self.assertEqual(arr, [1, 2, 4, 5, 7, 8]) arr = [3, 9, 8, 4, 6, 10, 2, 5, 7, 1] quick_sort(arr) self.assertEqual(arr, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
def test_quick(self): unsorted = [1, 2, 3, 4, 5] sorted_lst = [1, 2, 3, 4, 5] high = len(unsorted) - 1 low = 0 quick_sort(unsorted, low, high) self.assertEqual(sorted_lst, unsorted)
def best_and_worst_reviewed_products(): """ :return average_score_per_product: Sorted list of lists [product_id, average_score] """ average_score_per_product = [] cumulative_score_per_product = [[i + 1, 0] for i in range(number_products)] # Copying the list of lists is not working due to python binding, the element lists are bound sales_per_product_list = calculate_sales_per_product() for sale in lifestore_sales: product_id = sale[1] cumulative_score_per_product[product_id - 1][1] += sale[2] for cumulative_score in cumulative_score_per_product: product_id = cumulative_score[0] sales = sales_per_product_list[product_id - 1][1] # Only count them if they have been sold if sales > 0: average_score = cumulative_score[1] / sales average_score_per_product.append([product_id, average_score]) # Sort the list from minimum to maximum quick_sort(average_score_per_product, lambda x: x[1]) return average_score_per_product
def find_numbers(array, k): if len(array) < 2: return None if len(array) == 2: return array[0], array[1] length = len(array) quick_sort(array, 0, length - 1) print("sorted array: {}".format(array)) low, high = 0, length - 1 if array[low] + array[low + 1] >= k: return array[low], array[low + 1] if array[high] + array[high - 1] <= k: return array[high - 1], array[high] min_value = 1e10 a, b = 0, 0 while low < high: s = array[low] + array[high] if abs(s - k) <= min_value: min_value = abs(s - k) a = low b = high if s == k: return array[low], array[high] elif s > k: high -= 1 else: low += 1 return array[a], array[b]
def iterations(sort_type, n): # This function sorts randomly generated numbers of length n that range from -500 to 500 if sort_type == "selection sort": selection_sort.selection_sort([random.randint(-500,500) for number in range(n)]) elif sort_type == "merge sort": merge_sort.merge_sort([random.randint(-500,500) for number in range(n)]) elif sort_type == "quick sort": quick_sort.quick_sort([random.randint(-500,500) for number in range(n)])
def main(): arr = [9,2,6,4,3,5,1] quick_sort(arr, 0, len(arr)-1) for i in range(len(arr)): print ("%d" %arr[i])
def bucket_sort(data_list,bucket_size = DEFAULT_BUCKET_SIZE): length = len(data_list) min = max = data_list[0] #寻找最小值和最大值 for i in range(0,length): if data_list[i] < min: min = data_list[i] if data_list[i] > max: max = data_list[i] #定义多个桶并初始化 num_of_buckets = (max - min) // bucket_size +1 buckets = [] for i in range(num_of_buckets): buckets.append([]) #将数据放入桶中 for i in range(0,length): buckets[(data_list[i] - min)//bucket_size ].append(data_list[i]) #依次对桶内数据进行快速排序 data_list.clear() for i in range(num_of_buckets): print(f"第{i}个桶排序前的内容是{buckets[i]}") quick_sort(buckets[i]) # print(f"第{i}个桶排序后的内容是{buckets[i]}") for data in buckets[i]: data_list.append(data)
def find_median(self, a, begin, end): # use quick sort to sort in place x = begin + (end - begin) // 2 from quick_sort import quick_sort quick_sort(a, begin, end) return a[x]
def test_big_quick_sort(): ints = [i for i in range(0,10000)] mixed_ints = [i for i in range(0,10000)] assert ints == mixed_ints random.shuffle(mixed_ints) assert ints != mixed_ints quick_sort(mixed_ints) assert ints == mixed_ints
def test_single_number_list(): arr = [1] low = 0 high = 0 quick_sort(arr, low, high) actual = arr expected = [1] assert actual == expected
def test_quick_sort_edge_case_two(): arr = ['a', 'c', 'bond', '1b'] quick_sort(arr, 0, 3) assert arr == [ '1b', 'a', 'bond', 'c', ]
def get_times(lst, number_of_rep=10): times = [[], [], [], []] # last, rand, first, middle for x in range(number_of_rep): for index, fun in enumerate([quick_sort.partition_last, quick_sort.partition_rand, quick_sort.partition_first, quick_sort.partition_middle]): t1 = time.perf_counter() quick_sort.quick_sort(lst, 0, len(lst) - 1, fun) t1 = time.perf_counter() - t1 times[index].append(t1) return zip(*times)
def test_sorting(): import random datalist = [random.randint(0, 1e6) for i in xrange(100)] quick_sort(datalist) previous = datalist[0] for i in datalist[1:]: assert previous <= i previous = i
def test_quick_sort(build_list): x, y = build_list assert quick_sort(x) == y import random for i in xrange(100): x = [random.randint(10,100) for i in xrange(20)] y = merge_sort(x) z = quick_sort(x) assert y == z
def merge_quick_sort(L): """ This function inputs the value of unsorted list and invokes split function in the file merge_sort to split the list into two halves Then the function invokes the quick_sort function, then again it invokes the merge function in the merge_sort file and returns the sorted list :param L: The list which has to sorted :return: sorted list """ (half1, half2) = merge_sort.split(L) (l1, l2) = quick_sort.quick_sort(half1), quick_sort.quick_sort(half2) return merge_sort.merge(l1, l2)
def test_quick_sort(build_list): x, y = build_list assert quick_sort(x) == y import random for i in xrange(100): x = [random.randint(10, 100) for i in xrange(20)] y = merge_sort(x) z = quick_sort(x) assert y == z
def test_large_list_quick_sort(): lst = [ 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48, 71, -2, -60, 16, 40, 8 ] quick_sort(lst, 0, (len(lst) - 1)) assert lst == [ -60, -2, 2, 3, 4, 5, 8, 15, 16, 19, 26, 27, 36, 38, 40, 44, 46, 47, 48, 50, 71 ]
def menu_de_algoritmos(): print("Analise de algoritmos separadamente") print("(1) - Quick Sort") print("(2) - Merge Sort") print("(3) - Heap Sort") print("(4) - Radix Sort") option = input("Escolha uma opção: ") quantity = [100, 1000, 10000, 100000] limit = 1000**2 if option == '1': for i in quantity: lista = cria_lista(i, limit) inicio = time.time() quick_sort(lista, 0, len(lista)) fim = time.time() result = fim - inicio print("O tempo de ordenação do quicksort em um vetor de {} elementos é de {} segundos.".format(i, result)) elif option == '2': for i in quantity: lista = cria_lista(i, limit) inicio = time.time() merge_sort(lista) fim = time.time() result = fim - inicio print("O tempo de ordenação do mergesort em um vetor de {} elementos é de {} segundos.".format(i, result)) elif option == '3': for i in quantity: lista = cria_lista(i, limit) inicio = time.time() heapsort(lista) fim = time.time() result = fim - inicio print("O tempo de ordenação do heap em um vetor de {} elementos é de {} segundos.".format(i, result)) elif option == '4': for i in quantity: lista = cria_lista(i, limit) inicio = time.time() radix_sort(lista) fim = time.time() result = fim - inicio print("O tempo de ordenação do radix em um vetor de {} elementos é de {} segundos.".format(i, result))
def test_nearly_sorted(): """ A list of nearly sorted integers is sorted by QuickSort. """ expected = [2, 3, 5, 7, 11, 13] lst = [2, 3, 5, 7, 13, 11] quick_sort(lst, 0, len(lst) - 1) assert lst == expected
def test_randomly_sorted(): """ A randomly sorted list of integers is sorted by QuickSort. """ expected = [4, 8, 15, 16, 23, 42] lst = [8, 4, 23, 42, 16, 15] quick_sort(lst, 0, len(lst) - 1) assert lst == expected
def test_reverse_sorted(): """ A reverse sorted list of integers is sorted by QuickSort. """ expected = [-2, 5, 8, 12, 18, 20] lst = [20, 18, 12, 8, 5, -2] quick_sort(lst, 0, len(lst) - 1) assert lst == expected
def test_few_uniques(): """ A list with few unique integers is sorted by QuickSort. """ expected = [5, 5, 5, 7, 7, 12] lst = [5, 12, 7, 5, 5, 7] quick_sort(lst, 0, len(lst) - 1) assert lst == expected
def calculate_egalitarian_welfare(agents, rounds): welfares = [] welfare_idx = [] for idx, agent in enumerate(agents): welfares.append(agent.get_utility()) welfare_idx.append(idx) quick_sort.quick_sort(welfares, welfare_idx, 0, len(agents) - 1) return welfares[0], welfares[len(agents) - 1]
def test_quick_sort_edge_case(): arr = [ 2.5, -5, 0, 8, 7, 9, ] quick_sort(arr, 0, 5) assert arr == [-5, 0, 2.5, 7, 8, 9]
def __vote_for_slots_highest_preference(self): # Rank in terms of highest preference quick_sort.quick_sort(self.__popular_time_slots_preference, self.__popular_time_slots_idx, 0, self.__n_slots_consideration - 1) # Vote for n_votes time-slots with the highest preference from the n_slots_consideration most popular time slots for idx in range(self.__n_slots_consideration - self.__n_votes, self.__n_slots_consideration): self.environment.vote_time_slot(self.__popular_time_slots_idx[idx]) self._time_slots_chosen.append(self.__popular_time_slots_idx[idx])
def test_quick_sort(self): arr1 = [1, 5, 8, 4, 2, 9, 6, 0, 3, 7] arr2 = [] arr3 = [2] arr4 = [0, 1, 2, 3, 4, 5] arr5 = random.sample(range(200), 50) self.assertEqual(quick_sort(arr1), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) self.assertEqual(quick_sort(arr2), []) self.assertEqual(quick_sort(arr3), [2]) self.assertEqual(quick_sort(arr4), [0, 1, 2, 3, 4, 5]) self.assertEqual(quick_sort(arr5), sorted(arr5))
def sort_products_by_searches(): """ A function that calculates the number of searches per product and sorts them from best to worst and prints them :return searches_per_product_list: an ordered list """ # holds the index and the number of searches of each product_id searches_per_product_list = calculate_searches_per_product() quick_sort(searches_per_product_list, lambda x: x[1]) return searches_per_product_list
def test_quick_sort(): for i in range(500): array = [] for j in range(i): array.append(random.randrange(-i, i, 1)) temp = array.copy() temp.sort() quick_sort(array) assert temp == array
def pair_sort(pairings, bm_intpl, cutoff=0.): sorted = [] for key in pairings: L = len(pairings[key]) for i in range(L): # get the points pairwise for j in range(i+1,L): pt1,pt2 = pairings[key][i],pairings[key][j] duv = tuple(x - y for x,y in zip(pt1[2], pt2[2])) val = export_beam.get_overlap(bm_intpl,*duv) if abs(val) > cutoff: sorted.append((val,(pt1[0],pt1[1]),(pt2[0],pt2[1]),pt1[2])) quick_sort.quick_sort(sorted,0,len(sorted)-1) return sorted
def counting_element(s): #if array is empty, force quit if len(s) == 0: return #sort an array s = quick_sort(s) previous = s[0] # set previous to the first element in that array count = 0 # count is used to keep track of the element new_array = [] #this array is used to store the count elemnt new_array.append(count) #create first element of empty array j = 0 #go through the array and find the repeated elemnt of that aray for i in range(0,len(s)): if s[i] == previous: count = count + 1 new_array[j] = count else: #print("element:{0},appear:{1}".format(previous,count)) previous = s[i] # set previous to the next element count = 1 #reset this couting to 1 j = j + 1 # move to the next element of new_array new_array.append(count) # append to the next count of new element #print("element:{0},appear:{1}".format(previous,count)) return new_array
def test_stability(): """Test the statbility of the quick sort.""" from quick_sort import quick_sort lst = [(2, 'ab'), (1, 'ba'), (3, 'ab'), (2, 'ba'), (5, 'ab')] one = lst[0] two = lst[3] sort_lst = quick_sort(lst) assert sort_lst == [(1, 'ba'), (2, 'ab'), (2, 'ba'), (3, 'ab'), (5, 'ab')] assert sort_lst[1] is one assert sort_lst[2] is two
def return_k_element(s,k): count_element = counting_element(s) s = remove_sort(s) dictionary = put_to_dict(s,count_element) dictionary2 = quick_sort([(value,key) for (key,value) in dictionary.items()]) array_k = [] i = 0 while i <k: array_k.append(dictionary2[i][1]) i = i+1 return array_k
def main(): if len(sys.argv) != 2: print 'usage: ./compare_sort_algos.py --len_of_array' sys.exit(1) len_of_array = sys.argv[1] # This argument has length of the array to be sorted. print len_of_array # Create Random numbers of this length. The random numbers generated are unique. array = random.sample(xrange(10000000), int(len_of_array)) #print array sorted_array = insertion_sort.insertion_sort(array) insertion_time = time.clock() insertion_tot = insertion_time - start_time print ("Insertion Sort %s" % insertion_tot) sorted_array = selection_sort.selection_sort(array) selection_time = time.clock() selection_tot = selection_time - insertion_time print ("Selection Sort %s" % (selection_tot)) sorted_array = bubble_sort.bubble_sort(array) bubble_time = time.clock() bubble_tot = bubble_time - selection_time print ("Bubble Sort %s" % (bubble_tot)) sorted_array_m = merge_sort.merge_sort(array) merge_time = time.clock() merge_tot = merge_time - bubble_time print ("Merge Sort %s" % (merge_tot)) sorted_array_q = quick_sort.quick_sort(array) quick_time = time.clock() quick_tot = quick_time - merge_time print ("Quick Sort %s" % (quick_tot)) sorted_array_h = heap_sort.heap_sort(array) heap_time = time.clock() heap_tot = heap_time - quick_time print ("Heap Sort %s" % (heap_tot)) objects = ('Insertion', 'Selection', 'Bubble', 'Merge','Quick','Heap') y_pos = np.arange(len(objects)) performance = [insertion_tot/merge_tot,selection_tot/merge_tot,bubble_tot/merge_tot,merge_tot/merge_tot,quick_tot/merge_tot,heap_tot/merge_tot] if (sorted_array_m == sorted_array_q): print "Merge and Quick sorts are giving the same sorted array results" plt.bar(y_pos, performance, align='center', alpha=0.5) plt.xticks(y_pos, objects) plt.ylabel('Time taken w.r.t merge sort') plt.title('Sorting Techniques') plt.show()
def test_reverse(): reverse_list = [15, 10, 9, 8, 7, 5, 2, 0] sorted_reverse = quick_sort(reverse_list) assert sorted_reverse == sorted(reverse_list)
def test_sorts_no_items(self): arr = [] quick_sort(arr) self.assertEqual([], arr)
def xtests_sorts_many_items(self): arr = [4, 1, 2, 2, 1, 3, 3] quick_sort(arr) self.assertEqual([1, 1, 2, 2, 3, 3, 4], arr)
def test_simple(): simple_list = [10, 7, 8, 9, 2, 15, 0, 5] sorted_simple = quick_sort(simple_list) assert sorted_simple == sorted(simple_list)
def test_quicksort_01(): k = 10000 rand_list = [random.randint(-k, k) for i in xrange(k)] copy_of_list = rand_list[:] Q.quick_sort(rand_list) assert rand_list == sorted(copy_of_list)
def test_quick_sort(self): self.assertEqual(quick_sort.quick_sort(self._arr), self._res)
def test_random_lst(): """Test that a random list is sorted.""" from quick_sort import quick_sort lst_sort = sorted(rand_lst) assert quick_sort(rand_lst) == lst_sort
def test_quick_sort_empty(): """Test that was can pass an empty list.""" from quick_sort import quick_sort assert quick_sort([]) == []
def test_float(): float_list = [10, 7, 8, 9.5, 2.5, 15, 0, 5] sorted_float = quick_sort(float_list) assert sorted_float == sorted(float_list)
import quick_sort l = [[1, 5, 36, 67, 4, 7, 78, 100], [111, 23, 111], [1], []] result_sort = [[1, 4, 5, 7, 36, 67, 78, 100], [23, 111, 111], [1], []] for i in range(len(l)): try: ret_sort = quick_sort.quick_sort(l[i]) if ret_sort == result_sort[i]: print 'success', ret_sort else: print 'error1 : The %sth sorted %s is not equal to the expected result %s' % \ ( i, ret_sort, result_sort[i]) except: print 'select sort exception:', i
def test_quick_sort(self): result = quick_sort(self.arr) self.assertEqual(result, self.answer)
def test_already_sorted(): already_sorted = [0, 2, 5, 7, 8, 9, 10, 15] sorted_already = quick_sort(already_sorted) assert sorted_already == sorted(already_sorted)
def test_repeat(): repeat_list = [10, 7, 8, 9, 2, 15, 0, 5, 15] sorted_repeat = quick_sort(repeat_list) assert sorted_repeat == sorted(repeat_list)
def test_quick_sort_correctly_sorts(self): sorted_values = quick_sort(self.unsorted_values) self.assertEqual(sorted(self.unsorted_values), sorted_values)
def external_merge_sort(infilename, outfilename, word_size = 4, memory_limit = 1024*1024): TEMP_FILE_NAME = "temp.dat" with open(infilename, "rb") as infile: infile.seek(0, 2) infile_size = infile.tell() infile.seek(0, 0) with open(TEMP_FILE_NAME, "wb+") as temp_file, \ open(outfilename, "wb+") as out_file: # Phase 1: sort parts partsCount = 0 while infile.tell() < infile_size: # print "infile.tell():", infile.tell() bytes_left = (infile_size - infile.tell()) # values = array.array('I') # array of long integers values = array.array('B') values.fromfile(infile, min(memory_limit, bytes_left)/values.itemsize) # read integers # print "sorting part", partsCount + 1 quick_sort(values,partition_func = splitByMedian, leaf_sort_func = leaf_insertion_sort,trace=False) # radix_sort(values, 256); # print "after sort:", values values.tofile(temp_file) partsCount += 1 # Phase 2: n-way merge streamsList = [] for partIndex in xrange(partsCount): streamsList.append(Stream(temp_file, partIndex*memory_limit, \ min((partIndex+1)*memory_limit, infile_size), word_size)) # for stream in streamsList: # print stream out_buffer = array.array('B'); current_words = [stream.getWord() for stream in streamsList]; while len(streamsList) > 0: minIndex, minWord = min(enumerate(current_words), key=lambda e: e[1]) # minStream = streamsList[0] # minWord = minStream.getWord() # for stream in streamsList[1:]: # word = stream.getWord() # # print "word: {}, minWord: {}".format(word.encode('hex'), minStream.getWord().encode('hex')) # if word < minWord: # minStream = stream # minWord = word # print "writing: {}".format(minStream.getWord().encode('hex')) out_buffer.append(minWord) if out_buffer.buffer_info()[1] > 1024: out_buffer.tofile(out_file) out_buffer = array.array('B'); # out_file.write(minStream.getWord()) if streamsList[minIndex].next(): current_words[minIndex] = streamsList[minIndex].getWord() else: del streamsList[minIndex] del current_words[minIndex] out_buffer.tofile(out_file)
def tests_sorts_one_item(self): arr = [1] quick_sort(arr) self.assertEqual([1], arr)
def test_quicksort_03(): k = 10000 rand_list = [random.randint(-k, k) for i in xrange(k)] copy_of_list = rand_list[:] Q.quick_sort(rand_list, pivot_mode='best_of_three') assert rand_list == sorted(copy_of_list)
def tests_sorts_two_items(self): arr = [2, 1] quick_sort(arr) self.assertEqual([1, 2], arr)
def test_quick_sort_returns_an_array(self): sorted_values = quick_sort(self.unsorted_values) assert isinstance(sorted_values, list)
def test_long(): long_list = range(10000) shuffle(long_list) sorted_long = quick_sort(long_list) assert sorted_long != long_list assert sorted_long == sorted(long_list)