def test_sort_unsorted_list_of_integers(self): """Test that when insertion sort is passed an unsorted list of integers that the list is properly sorted. """ insertion_sort(self.unsorted_list_of_integers) self.assertEqual(self.unsorted_list_of_integers, self.sorted_list_of_integers)
def test_sort_sorted_list_of_integers(self): """Test that when insertion sort is passed a sorted list of integers that the list remains sorted. """ insertion_sort(self.sorted_list_of_integers) self.assertEqual(self.sorted_list_of_integers, [-7, -2, -1, 0, 1, 4, 10])
def test_insertion_sort_is_stable(self): """Test that if two elements in a list have the same key, that their relative ordering is still preserved after the list is sorted. """ insertion_sort(self.unsorted_list_of_products) self.assertEqual(self.unsorted_list_of_products, self.sorted_list_of_products_stable)
def radix_sort(seq): n, divisor = len(seq), 10 min_a, max_a = find_min.find_min(seq), find_max.find_max(seq) for i in range(n): seq[i] += abs(min_a) while divisor / 10 <= max_a: blocks = [[] for _ in range(10)] for i in range(n): digit = seq[i] % divisor - seq[i] % (int(divisor / 10)) while digit >= 10: digit /= 10 print(seq[i], digit, divisor) blocks[int(digit)].append(seq[i]) j = 0 for block_i in range(10): if blocks[block_i]: blocks[block_i] = insertion_sort.insertion_sort( blocks[block_i]) for k in range(len(blocks[block_i])): seq[j] = blocks[block_i][k] j += 1 divisor *= 10 for i in range(n): seq[i] += min_a return seq
def flash_sort(seq): n, min_a = len(seq), find_min.find_min(seq) max_i = 0 for i in range(n): if seq[max_i] < seq[i]: max_i = i m = int(0.42 * n) cft = (m - 1) / (seq[max_i] - min_a) dist_table = [0 for _ in range(m)] for i in range(n): dist_table[int(cft * (seq[i] - min_a))] += 1 print(dist_table) for k in range(1, m): dist_table[k] += dist_table[k - 1] print(dist_table) seq[0], seq[max_i] = seq[max_i], seq[0] moves, j = 0, 0 k = m - 1 print(seq) while moves < n - 1: while j > (dist_table[k] - 1): j += 1 k = int(cft * (seq[j] - min_a)) print(j) while j != dist_table[k]: k = int(cft * (seq[j] - min_a)) seq[dist_table[k] - 1], seq[j] = seq[j], seq[dist_table[k] - 1] dist_table[k] -= 1 moves += 1 print(seq, dist_table) return insertion_sort.insertion_sort(seq)
def test_insertion_sort_empty(): ''' Tests insertion sort if given an empty list ''' lst = [] assert_equals(insertion_sort(lst), [])
def test_insertion_sort_normal(): ''' Tests insertion sort given a normal list ''' lst = [5, 2, 4, 6, 1, 3] correct = [1, 2, 3, 4, 5, 6] assert_equals(insertion_sort(lst), correct)
def bucket_sort(sortable, num_of_buckets): #Put the numbers into buckets the_min = min(sortable) the_range = (max(sortable)-the_min)/num_of_buckets buckets = [[] for i in range(num_of_buckets)] for x in sortable: bucket_num = (x-the_min)//the_range if bucket_num == num_of_buckets: bucket_num -= 1 buckets[bucket_num].append(x) #Sort item in buckets and put back into list i=0 for bucket in buckets: insertion_sort(bucket) for num in bucket: sortable[i] = num i += 1 return sortable
def solomon_sort(seq): n, min_a, max_a = len(seq), find_min.find_min(seq), find_max.find_max(seq) delta = (max_a - min_a) / n buckets = [[] for _ in range(n)] print(delta) for i in range(n): new_index = (seq[i] - min_a) / delta if (seq[i] - min_a) / delta > 1 else 1 buckets[int(new_index) - 1].append(seq[i]) j = 0 for bucket_i in range(n): if buckets[bucket_i]: buckets[bucket_i] = insertion_sort.insertion_sort(buckets[bucket_i]) for i in range(len(buckets[bucket_i])): seq[j] = buckets[bucket_i][i] j += 1 return seq
def solomon_sort(seq): n, min_a, max_a = len(seq), find_min.find_min(seq), find_max.find_max(seq) delta = (max_a - min_a) / n buckets = [[] for _ in range(n)] print(delta) for i in range(n): new_index = (seq[i] - min_a) / delta if (seq[i] - min_a) / delta > 1 else 1 buckets[int(new_index) - 1].append(seq[i]) j = 0 for bucket_i in range(n): if buckets[bucket_i]: buckets[bucket_i] = insertion_sort.insertion_sort( buckets[bucket_i]) for i in range(len(buckets[bucket_i])): seq[j] = buckets[bucket_i][i] j += 1 return seq
def draw_chart(sort_type, original_data, frame_interval): fig = plt.figure(1, figsize=(16, 9)) data_set = [Data(d) for d in original_data] axs = fig.add_subplot(111) plt.subplots_adjust(left=0.01, bottom=0.01, right=0.99, top=0.95) if sort_type == 1: frames = selection_sort(data_set) elif sort_type == 2: frames = bubble_sort(data_set) elif sort_type == 3: frames = insertion_sort(data_set) elif sort_type == 4: frames = merge_sort(data_set) elif sort_type == 5: frames = quick_sort(data_set) else: raise IndexError def animate(frame_no): # if fi % 2 != 0 and frame_interval < 10 and fi != len(frames)-1: # return bars = [] if len(frames) > frame_no: axs.cla() axs.set_title(s_type[sort_type]) axs.set_xticks([]) axs.set_yticks([]) bars += axs.bar(list(range(Data.length)), [d.value for d in frames[frame_no]], 1, color=[d.color for d in frames[frame_no]]).get_children() frame_no += 1 return bars anim = animation.FuncAnimation(fig, animate, frames=len(frames), interval=frame_interval, repeat=False) return plt, anim
def bucket_sort(v): n = len(v) B = [] for i in range(0, n): B.append([]) for i in range(0, n): idx = math.floor(n * v[i]) B[idx].append(v[i]) for i in range(0, n): B[i] = insertion_sort(B[i]) idx = 0 for i in range(0, n): for j in range(0, len(B[i])): v[idx] = B[i][j] idx += 1 return v
def bucket_sort(seq, num_of_buckets=10): n = len(seq) min_a = find_min.find_min(seq) for i in range(n): seq[i] += abs(min_a) print(seq) buckets = [[] for _ in range(num_of_buckets)] max_a = find_max.find_max(seq) divider = ceil((max_a + 1) / num_of_buckets) print(divider) for i in range(n): buckets[int(seq[i] // divider)].append(seq[i]) j = 0 print(buckets) for bucket_i in range(num_of_buckets): if buckets[bucket_i]: buckets[bucket_i] = insertion_sort.insertion_sort(buckets[bucket_i]) for k in range(len(buckets[bucket_i])): seq[j] = buckets[bucket_i][k] j += 1 for i in range(n): seq[i] += min_a return seq
def radix_sort(seq): n, divisor = len(seq), 10 min_a, max_a = find_min.find_min(seq), find_max.find_max(seq) for i in range(n): seq[i] += abs(min_a) while divisor / 10 <= max_a: blocks = [[] for _ in range(10)] for i in range(n): digit = seq[i] % divisor - seq[i] % (int(divisor / 10)) while digit >= 10: digit /= 10 print(seq[i], digit, divisor) blocks[int(digit)].append(seq[i]) j = 0 for block_i in range(10): if blocks[block_i]: blocks[block_i] = insertion_sort.insertion_sort(blocks[block_i]) for k in range(len(blocks[block_i])): seq[j] = blocks[block_i][k] j += 1 divisor *= 10 for i in range(n): seq[i] += min_a return seq
def bucket_sort(seq, num_of_buckets=10): n = len(seq) min_a = find_min.find_min(seq) for i in range(n): seq[i] += abs(min_a) print(seq) buckets = [[] for _ in range(num_of_buckets)] max_a = find_max.find_max(seq) divider = ceil((max_a + 1) / num_of_buckets) print(divider) for i in range(n): buckets[int(seq[i] // divider)].append(seq[i]) j = 0 print(buckets) for bucket_i in range(num_of_buckets): if buckets[bucket_i]: buckets[bucket_i] = insertion_sort.insertion_sort( buckets[bucket_i]) for k in range(len(buckets[bucket_i])): seq[j] = buckets[bucket_i][k] j += 1 for i in range(n): seq[i] += min_a return seq
def test_merge_sort_empty(self): arr_one: List[int] = [] insertion_sort.insertion_sort(arr_one) self.assertEqual([], arr_one)
def test_insertion_sort(self): self.assertEqual(insertion_sort.insertion_sort(self.array), self.sorted_array)
def test_sort_empty_list(self): """Test that when insertion sort is passed an empty list, that nothing happens.""" insertion_sort(self.empty_list) self.assertEqual(self.empty_list, [])
def test_insertion_sort(self): for test, assertion in self.test_cases: with self.subTest(): self.assertEqual(insertion_sort(test), assertion)
def test_merge_sort_one(self): arr_one: List[int] = [10] insertion_sort.insertion_sort(arr_one) self.assertEqual([10], arr_one)
def test_merge_sort_desc(self): expected: List[int] = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] insertion_sort.insertion_sort(arr, True) self.assertEqual(expected, arr)
def test_merge_sort_asc(self): expected: List[int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] insertion_sort.insertion_sort(arr) self.assertEqual(expected, arr)
def test_sort(): xs = list(np.random.randint(0, 1000, size=[1000])) assert insertion_sort(xs) is None assert xs == sorted(xs)