def tim_sort(arr, n): # Sort individual subarrays of size RUN for i in range(0, n, RUN): sort(arr, i, min((i+31), (n-1))) # start merging from size RUN (or 32). It will merge # to form size 64, then 128, 256 and so on .... size = RUN while size < n: # pick starting point of left sub array. We # are going to merge arr[left..left+size-1] # and arr[left+size, left+2*size-1] # After every merge, we increase left by 2*size for left in range(0, n, 2*size): # find ending point of left sub array # mid+1 is starting point of right sub array mid = left + size - 1 right = min((left + 2*size - 1), (n-1)) # merge sub array arr[left.....mid] & # arr[mid+1....right] merge(arr, left, mid, right) size = 2*size
def sort(array, bucketSize=DEFAULT_BUCKET_SIZE): if len(array) == 0: return array # Determine minimum and maximum values minValue = array[0] maxValue = array[0] for i in range(1, len(array)): if array[i] < minValue: minValue = array[i] elif array[i] > maxValue: maxValue = array[i] # Initialize buckets bucketCount = math.floor((maxValue - minValue) / bucketSize) + 1 buckets = [] for i in range(0, bucketCount): buckets.append([]) # Distribute input array values into buckets for i in range(0, len(array)): buckets[math.floor((array[i] - minValue) / bucketSize)].append(array[i]) # Sort buckets and place back into input array array = [] for i in range(0, len(buckets)): insertion_sort.sort(buckets[i]) for j in range(0, len(buckets[i])): array.append(buckets[i][j]) return array
def sort(array, bucketSize=DEFAULT_BUCKET_SIZE): if len(array) == 0: return array # Determine minimum and maximum values minValue = array[0] maxValue = array[0] for i in range(1, len(array)): if array[i] < minValue: minValue = array[i] elif array[i] > maxValue: maxValue = array[i] # Initialize buckets bucketCount = math.floor((maxValue - minValue) / bucketSize) + 1 buckets = [] for i in range(0, bucketCount): buckets.append([]) # Distribute input array values into buckets for i in range(0, len(array)): buckets[math.floor( (array[i] - minValue) / bucketSize)].append(array[i]) # Sort buckets and place back into input array array = [] for i in range(0, len(buckets)): insertion_sort.sort(buckets[i]) for j in range(0, len(buckets[i])): array.append(buckets[i][j]) return array
def main(): unsorted = [random.randint(-999, 9999) for i in range(0, 25)] print("unsorted list:", unsorted) bubble_sort.sort(unsorted) merge_sort.sort(unsorted) insertion_sort.sort(unsorted) quick_sort.sort(unsorted)
def sort(a, p, q, k=8): if q - p < k: return insertion_sort.sort(a, p, q) if p < q: r = (p + q) // 2 sort(a, p, r, k) sort(a, r + 1, q, k) merge(a, p, r, q) return a
def test_sort(self): """ Compare results of sorting a random list with insertion sort against sorting that same list using Python's built sorting. """ test_list = [] for x in range(10000): test_list.append(randrange(0, 100000)) expected = sorted(test_list) result = insertion_sort.sort(test_list) self.assertEqual(expected, result)
def sort(array, max_value): buckets = [[] for _ in range(len(array))] for i in range(len(array)): j = int(array[i] / (max_value / len(array))) if j != len(array): buckets[j].append(array[i]) else: buckets[j - 1].append(array[i]) for i in range(len(array)): insertion_sort.sort(buckets[i]) result = [] for i in range(len(array)): result.extend(buckets[i]) return result
def bucket_sort(A: list): C = [] length = len(A) B = [None] * length for i in range(length): B[i] = [None] for j in A: if B[int((length * j) // 1)] == [None]: B[int((length * j) // 1)] = [j] else: B[int((length * j) // 1)].append(j) for k in B: if not k == [0]: insertion_sort.sort(k) for x in B: if x == [None]: continue C = C + x return C
def quicker_sort(it): if len(it) < 10: return insertion_sort.sort(it) pivot = it.pop(get_pivot(it)) less, greater = [], [] for x in it: if x < pivot: less.append(x) else: greater.append(x) return sort(less) + [pivot] + sort(greater)
def test_dataset3(self): inputData = [90, -20, 8, 11, 3] expectedData = [-20, 3, 8, 11, 90] self.assertEqual(sort(inputData), expectedData)
def test_dataset2(self): inputData = [20, 2, 10, 6, 52, 31, 0, 45, 79, 40] expectedData = [0, 2, 6, 10, 20, 31, 40, 45, 52, 79] self.assertEqual(sort(inputData), expectedData)
def test_sortrandorder(self): arr = [random.randint(0, 10000) for i in xrange(0, 10000)] sortarr = sort(arr) for i in xrange(1, 10000): self.assertGreaterEqual(sortarr[i], sortarr[i - 1])
def test_sorted_list(): sorted_list = [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6] in_sort.sort(sorted_list) assert sorted_list == [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6]
def test_sort(self): array = [0, 5, 1, 9, 4, 0, 2, 4] expected = [0, 0, 1, 2, 4, 4, 5, 9] self.assertEqual(expected, sort(array))
def test_insertion_sort(): list_of_items = [54, 26, 93, 17, 77, 31, 44, 55, 20] print(list_of_items) insertion_sort.sort(list_of_items) print(list_of_items)
def test_dataset1(self): inputData = [5, 3, 6, 9, 10, 45, 23, 12, 4, 2] expectedData = [2, 3, 4, 5, 6, 9, 10, 12, 23, 45] self.assertEqual(sort(inputData), expectedData)
def test_insertionsort_should_handle_edge_cases(self): for k,v in self.i_o: self.assertEqual(insertion_sort.sort(k), v)
def test_insertionsort_should_sort_lists_correctly(self): for k,v in self.i_o: self.assertEqual(insertion_sort.sort(k), v)
import pattern_search import perfect_number import prime_factorisation import prime_number import quick_sort import selection_sort import sieve_of_eratosthenes import transposition_cipher """ SORTING """ bubble_sort.sort(array=[3, 2, 11, -1, 0]) array = [0.48, 0.27, 0.12, 0.21, 0.43, 0.25] bucket_sort.sort(array, max_value=max(array)) insertion_sort.sort(array=[3, 2, 11, -1, 0]) merge_sort.sort(array=[3, 2, 11, -1, 0]) array = [3, 2, 11, -1, 0] quick_sort.sort(array, left=0, right=len(array) - 1) selection_sort.sort(array=[3, 2, 11, -1, 0]) lexicographic_order.order(words=['aab', 'aaa', 'aa', 'aaa']) """ SEARCHING """ pattern_search.search(text=list('karykatura'), pattern=list('ka')) bisection_root_finding.bisect(a=-4, b=4, error=0.001)
def test_insertion(self): for arr in self.test_arr: insertion_sort.sort(arr) self.assertEqual(arr, sorted(arr))
def test_dataset4(self): inputData = [33, 22, 11, 21, 55, 32, 3, 4] expectedData = [3, 4, 11, 21, 22, 32, 33, 55] self.assertEqual(sort(inputData), expectedData)
def test_dataset5(self): inputData = [11, 22, 33, 44, 55, 66, 77] expectedData = [77, 66, 55, 44, 33, 22, 11] self.assertEqual(sort(inputData, True), expectedData)
def test_empty_list(): empty = [] in_sort.sort(empty) assert empty == []
def test_sort_inorder(self): arr = [i for i in xrange(0, 10000)] sortarr = sort(arr) for i in xrange(1, 10000): self.assertGreaterEqual(sortarr[i], sortarr[i-1])
import sys sys.path.insert(0, '../') from Utils import * from insertion_sort import sort # MAIN print("Unsorted list is: {0}".format(ARRAY_10)) sorted = sort(ARRAY_10) print("Sorted list is: {0}".format(sorted))
def test_insertion(self): for array in self.test_array: self.assertEqual(insertion_sort.sort(array), sorted(array))
def test_insertionsort_should_sort_lists_correctly(self): for k, v in self.i_o: self.assertEqual(insertion_sort.sort(k), v)
def test_sortrandorder(self): arr = [random.randint(0, 10000) for i in xrange(0,10000)] sortarr = sort(arr) for i in xrange(1, 10000): self.assertGreaterEqual(sortarr[i], sortarr[i-1])
def test_insertionsort_should_handle_edge_cases(self): for k, v in self.i_o: self.assertEqual(insertion_sort.sort(k), v)
def test_unsorted_list(): unsorted_list = [6, 2, 8, 4, 5, 3, 3, 4, 88, 2, 99, -43, 0] in_sort.sort(unsorted_list) assert unsorted_list == [-43, 0, 2, 2, 3, 3, 4, 4, 5, 6, 8, 88, 99]
def test_sort_revorder(self): arr = [i for i in xrange(10000, 0, -1)] sortarr = sort(arr) for i in xrange(1, 10000): self.assertGreaterEqual(sortarr[i], sortarr[i - 1])