def test_insertion_sort(seq): """Test insertion sort results equal build-in python sort results.""" from insertion_sort import insertion_sort seq = list(seq) sorted_copy = sorted(seq) insertion_sort(seq) assert seq == sorted_copy
def bucket_sort(item, begin, end, key=None): if key is None: key = lambda x: x[0] if isinstance(x, ( list, tuple, )) else x size = end - begin + 1 buckets = [None] * size i = begin while i <= end: if buckets[int(size * key(item[i]))] is None: buckets[int(size * key(item[i]))] = [item[i]] else: buckets[int(size * key(item[i]))].append(item[i]) i += 1 i = 0 while i < size: if buckets[i] is not None: insertion_sort(buckets[i], 0, len(buckets[i]) - 1, condition=lambda a, b: key(a) <= key(b) ) # equality must be check for stable sorting i += 1 i = 0 for bucket in buckets: if bucket is not None: for e in bucket: item[begin + i] = e i += 1
def main(): list = [12, 11, 13, 5, 6] insertion_sort(list) for i in range(len(list)): print("%d" % list[i])
def extract(buckets, array, order): ''' Copy elements from buckets back to array. ''' if order == 'asc': i = 0 d = 1 else: i = len(array) - 1 d = -1 for bucket in buckets: if not bucket: continue if len(bucket) > 1: # sort bucket first insertion_sort(bucket) for b in bucket: array[i] = b i += d else: # bucket only has one element array[i] = bucket[0] i += d
def bucket_sort(array, bucketSize=6): 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(buckets[i]) for j in range(0, len(buckets[i])): array.append(buckets[i][j]) return array
def bucket_sort(arr): if len(arr) < 2: return arr # pick a number of buckets k = (1 + len(arr) // 2) # make list of buckets bucket_arr = [[] for n in range(k)] # find maximum max_value = arr[0] for i in range(len(arr)): if arr[i] > max_value: max_value = arr[i] # sort each element into a bucket for j in range(len(arr)): # each element goes into a bucket that is its fraction of the maximum bucket_number = math.floor((arr[j] / (max_value + 1) * k)) bucket_arr[bucket_number].append(arr[j]) for arr in bucket_arr: insertion_sort(arr) output = [] for bucket in bucket_arr: output += bucket return output
def is_permutation(str1, str2): if type(str1) != t.StringType or type(str2) != t.StringType: raise TypeError("Both arguements must be string") str1 = str1.rstrip() str2 = str2.rstrip() if str1 == "" or str2 == "": raise ValueError("Both of the arguements must be non-emtpy") arr1 = [x for x in str1] arr2 = [y for y in str2] size1 = len(arr1) size2 = len(arr2) if size1 != size2: return False arr1 = i.insertion_sort(arr1, size1) arr2 = i.insertion_sort(arr2, size2) j = 0 k = 0 while j < size1: if arr1[j] != arr2[k]: return False j += 1 k += 1 return True
def timsort(items): min_subsection_size = 32 # Sort each subsection of size 32 # (The real algorithm carefully chooses a subsection size for performance.) for i in range(0, len(items), min_subsection_size): insertion_sort(items, i, min((i + min_subsection_size - 1), len(items) - 1)) # Move through the list of subsections and merge them using merge_sorted_lists # (Again, the real algorithm carefully chooses when to do this.) size = min_subsection_size while size < len(items): for start in range(0, len(items), size * 2): midpoint = start + size - 1 end = min((start + size * 2 - 1), (len(items) - 1)) # arithmetic to properly index # Merge using merge_sorted_lists merged_array = merge_sorted_lists(items[start:midpoint + 1], items[midpoint + 1:end + 1]) items[start:start + len(merged_array)] = merged_array # Insert merged array size *= 2 # Double the size of the merged chunks each time until it reaches the whole list return items
def test_alg(alg, size_array): """ Tests """ t_arrays = [] # Create the random arrays for i in range(N_TESTS_ALG): a = [randint(-2**N_BITS, 2**N_BITS) for i in range(size_array)] t_arrays.append(a) # Insertion Sort if alg == INSERTION_SORT: print("INSERTION_SORT", end=",") print("N=%d" % (size_array)) # Test N times to get a more precise average time for test in range(N_TESTS_ALG): A = list.copy(t_arrays[test]) t1 = time() insertion_sort(A) t2 = time() print("T%d," % test, t2 - t1) elif alg == MERGE_SORT: print("MERGE_SORT", end=",") print("N=%d" % (size_array)) # Test N times to get a more precise average time for test in range(N_TESTS_ALG): A = list.copy(t_arrays[test]) t1 = time() merge_sort(A, 0, len(A) - 1) t2 = time() print("T%d," % test, t2 - t1) elif alg == RADIX_SORT: print("RADIX_SORT", end=",") print("N=%d" % (size_array)) # Test N times to get a more precise average time for test in range(N_TESTS_ALG): A = list.copy(t_arrays[test]) t1 = time() radix_sort(A) t2 = time() print("T%d," % test, t2 - t1) elif alg == BUCKET_SORT: print("BUCKET_SORT", end=",") print("N=%d" % (size_array)) # Test N times to get a more precise average time for test in range(N_TESTS_ALG): A = list.copy(t_arrays[test]) t1 = time() bucket_sort(A, len(A)) t2 = time() print("T%d," % test, t2 - t1)
def merge_ins_sort(array, partition=2): """ Although merge sort runs faster than insertion sort asymptotically, the constant factors in insertion sort can make it faster in practice for small problem sizes on many machines. Thus, it makes sense to coarsen the leaves of the recursion by using insertion sort within merge sort when subproblems become sufficiently small. Consider a modification to merge sort in which n/k sublists of length k are sorted using insertion sort and then merged using the standard merging mechanism, where k is a value to be determined. bottom to top version with number of sublists specified :param array: :param partition: number of sublists :return: """ assert partition > 0 n = len(array) sublist_length = math.ceil(n / partition) sublist_number = partition for i in range(sublist_number): left = sublist_length * i right = min(sublist_length * (i + 1) - 1, n - 1) insertion_sort(array, left, right) while sublist_number > 1: for i in range(0, sublist_number - 1, 2): merge_with_sentinel(array, sublist_length * i, sublist_length * (i + 1) - 1, min(sublist_length * (i + 2) - 1, n - 1)) sublist_length *= 2 sublist_number = math.ceil(sublist_number / 2)
def quick_sort_three_ways(arr, l, r): if r - l <= 15: insertion_sort(arr) return lt, gt = partition_three_ways(arr, l, r) quick_sort_three_ways(arr, l, lt - 1) quick_sort_three_ways(arr, gt, r)
def run_insertion_sort(): rand_arr = utils.generate_random_array(101) rand_copy = list(rand_arr) rand_arr.sort() insertion_sort(rand_copy) assert_true(utils.compare_arrays(rand_arr, rand_copy), True, 'Insertion Sort')
def quick_sort(datalist, start=0, end=None): if end is None: end = len(datalist) size = end - start if size <= 1: return halfway = size // 2 + start pivot_choices = [datalist[start], datalist[halfway], datalist[end - 1]] insertion_sort(pivot_choices) pivot = pivot_choices[1] left_pointer = start right_pointer = end - 1 while left_pointer <= right_pointer: while datalist[left_pointer] < pivot: left_pointer += 1 while datalist[right_pointer] > pivot: right_pointer -= 1 if left_pointer <= right_pointer: datalist[left_pointer], datalist[right_pointer] = \ datalist[right_pointer], datalist[left_pointer] left_pointer += 1 right_pointer -= 1 quick_sort(datalist, start, right_pointer + 1) quick_sort(datalist, left_pointer, end)
def quick_sort_two_ways(arr, l, r): if r - l <= 15: insertion_sort(arr) return p = partition_two_ways(arr, l, r) quick_sort_two_ways(arr, l, p - 1) quick_sort_two_ways(arr, p + 1, r)
def merge_sort(a_list): if len(a_list) <= 5: insertion_sort(a_list) return a_list mid = len(a_list) // 2 p1 = a_list[mid:] p2 = a_list[:mid] p1 = merge_sort(p1) p2 = merge_sort(p2) i = 0 j = 0 merged_list = [None] * (len(p1) + len(p2)) while i < len(p1) and j < len(p2): if p1[i] < p2[j]: merged_list[i + j] = p1[i] i += 1 else: merged_list[i + j] = p2[j] j += 1 while i < len(p1): merged_list[i + j] = p1[i] i += 1 while j < len(p2): merged_list[i + j] = p2[j] j += 1 return merged_list
def timsort(val_list, k): if len(val_list) <= k: insertion_sort(val_list) elif len(val_list) > 1: mid_index = len(val_list) // 2 left = val_list[:mid_index] right = val_list[mid_index:] mergesort(left) mergesort(right) val_index = 0 l_index = 0 r_index = 0 while r_index < len(right) and l_index < len(left): if right[r_index] < left[l_index]: val_list[val_index] = right[r_index] r_index += 1 else: val_list[val_index] = left[l_index] l_index += 1 val_index += 1 while r_index < len(right): val_list[val_index] = right[r_index] r_index += 1 val_index += 1 while l_index < len(left): val_list[val_index] = left[l_index] l_index += 1 val_index += 1 return(val_list)
def testInsertion(self): result = copy(self.original) before = time.time() insertion_sort(result) after = time.time() print("Insertion Sort, size: %d time: %f" % (self.list_length, after-before)) self.assertEqual(self.sorted_list, result, "Insertion Sort Failed")
def bucketSort(myList, bucketSize=DEFAULT_BUCKET_SIZE): if(len(myList) == 0): print('You don\'t have any elements in array!') minValue = myList[0] maxValue = myList[0] # For finding minimum and maximum values for i in range(0, len(myList)): if myList[i] < minValue: minValue = myList[i] elif myList[i] > maxValue: maxValue = myList[i] # Initialize buckets bucketCount = math.floor((maxValue - minValue) / bucketSize) + 1 buckets = [] for i in range(0, bucketCount): buckets.append([]) # For putting values in buckets for i in range(0, len(myList)): buckets[math.floor((myList[i] - minValue) / bucketSize)].append(myList[i]) # Sort buckets and place back into input array sortedArray = [] for i in range(0, len(buckets)): insertion_sort(buckets[i]) for j in range(0, len(buckets[i])): sortedArray.append(buckets[i][j]) return sortedArray
def bucket_sort(array): # n = 0 largest = max(array) length = len(array) size = largest / length buckets = [[] for _ in range(length)] for i in range(length): j = int(array[i] / size) if j != length: buckets[j].append(array[i]) else: buckets[length - 1].append(array[i]) # n += 1 for i in range(length): # buckets[i], m = insertion_sort.insertion_sort(buckets[i]) # n += m insertion_sort.insertion_sort(buckets[i]) array = [] for i in range(length): array = array + buckets[i] return array
def bucket_sort(arr, bucket_size=10): """ 桶排序 算法说明 1. 设置一个定量的数组当作空桶; 2. 遍历输入数据,并且把数据一个一个放到对应的桶里去; 3. 对每个不是空的桶进行排序; 4. 从不是空的桶里把排好序的数据拼接起来。 """ if len(arr) == 0: return arr min_value = min(arr) max_value = max(arr) # 桶的初始化 bucket_count = (max_value - min_value) // bucket_size + 1 buckets = [[] for i in range(bucket_count)] # 利用映射函数将数据分配到各个桶中 for i in range(len(arr)): buckets[(arr[i] - min_value) // bucket_size].append(arr[i]) arr = [] for i in range(len(buckets)): insertion_sort(buckets[i]) for j in range(len(buckets[i])): arr.append(buckets[i][j]) return arr
def bucketSort(myList, bucketSize=DEFAULT_BUCKET_SIZE): if (len(myList) == 0): print('You don\'t have any elements in array!') minValue = myList[0] maxValue = myList[0] # For finding minimum and maximum values for i in range(0, len(myList)): if myList[i] < minValue: minValue = myList[i] elif myList[i] > maxValue: maxValue = myList[i] # Initialize buckets bucketCount = math.floor((maxValue - minValue) / bucketSize) + 1 buckets = [] for i in range(0, bucketCount): buckets.append([]) # For putting values in buckets for i in range(0, len(myList)): buckets[math.floor( (myList[i] - minValue) / bucketSize)].append(myList[i]) # Sort buckets and place back into input array sortedArray = [] for i in range(0, len(buckets)): insertion_sort(buckets[i]) for j in range(0, len(buckets[i])): sortedArray.append(buckets[i][j]) return sortedArray
def merge_insertion_sort(k, items, p, r): if k > r - p: insertion_sort.insertion_sort(items, p, r) else: q = (p + r) / 2 merge_insertion_sort(k, items, p, q) merge_insertion_sort(k, items, q + 1, r) merge_sort.merge(items, p, q, r)
def test_insertion_sort_not_list_error(): """Tests that the insertion sort method throws an appropriate error if it's called on an object that isn't a valid python list.""" from insertion_sort import insertion_sort test_string = "I am a string. Huzzah!" with pytest.raises(TypeError) as message: insertion_sort(test_string) assert "Your input must be a Python list." in str(message)
def bucket_sort(A): n = len(A) B = [[] for _ in range(n)] for i in range(n): B[floor(n * A[i])].append(A[i]) for i in range(n): insertion_sort(B[i]) return [e for sub in B for e in sub]
def adasort_helper(l, start, end, depth): if end <= start + 16: insertion_sort(l, start, end) elif depth == 0: heapsort(l, start, end) else: bls = hoare_partition(l, start, end) adasort_helper(l, start, bls, depth - 1) adasort_helper(l, bls + 1, end, depth - 1)
def test_stable(): """Test identical items in list retain stable position on sort.""" from insertion_sort import insertion_sort check_list = [1, 0, 2, 3, 2] two_a = check_list[2] two_b = check_list[4] insertion_sort(check_list) assert check_list[2] is two_a assert check_list[3] is two_b
def test_sorting(): import random datalist = [random.randint(0, 1e8) for i in xrange(100)] insertion_sort(datalist) previous = datalist[0] for i in datalist[1:]: assert previous <= i previous = i
def test_weird_insertion_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 insertion_sort(mixed_ints) assert ints == mixed_ints
def test_stable_random(seq): """Test stability property on random lists.""" from insertion_sort import insertion_sort seq = list(seq) index_a, index_b = sorted(random.sample(range(len(seq)), 2)) val_a, val_b = -1, -1 seq[index_a], seq[index_b] = val_a, val_b insertion_sort(seq) assert seq[0] is val_a assert seq[1] is val_b
def bucket_sort(a): n = len(a) b = [[] for x in range(n)] for x in a: b[int(n * x)].append(x) c = [] for i in range(n): insertion_sort(b[i]) c += b[i] return c
def test_stable_random_2(seq): """Test stability property on random lists sorting the other direction.""" from insertion_sort import insertion_sort seq = list(seq) index_a, index_b = sorted(random.sample(range(len(seq)), 2)) val_a, val_b = 1000, 1000 seq[index_a], seq[index_b] = val_a, val_b insertion_sort(seq) assert seq[-1] is val_b assert seq[-2] is val_a
def merge_sort1(arr): # if len(arr) <= 1: # return arr if len(arr) <= 15: insertion_sort(arr) return arr mid = len(arr) // 2 left = merge_sort1(arr[:mid]) right = merge_sort1(arr[mid:]) if arr[:mid][-1] > arr[mid:][0]: return merge(left, right)
def measure_runtime(alg, arr): if alg == 'merge': start_time = time.time() merge_sort(arr, 0, len(arr)) res = time.time() - start_time elif alg == 'insert': start_time = time.time() insertion_sort(arr) res = time.time() - start_time return res
def test_insertion_sort(): for i in range(500): array = [] for j in range(i): array.append(random.randrange(-i, i, 1)) temp = array.copy() temp.sort() insertion_sort(array) assert array == temp
def test_insertion_sort(self): lst1 = [1, 2, 3, 4, 5] lst1 = insertion_sort(lst1) self.assertEqual(lst1, [1, 2, 3, 4, 5]) lst2 = [5, 4, 3, 2, 1] lst2 = insertion_sort(lst2) self.assertEqual(lst2, [1, 2, 3, 4, 5]) lst3 = [2, 4, 3, 4, 5, 5, 1] lst3 = insertion_sort(lst3) self.assertEqual(lst3, [1, 2, 3, 4, 4, 5, 5])
def main(argv): progname = argv[0] if (len(argv) != 2): print 'Usage: {0} <filename>'.format(argv[0]) print 'Example: {0} random_num.txt'.format(argv[0]) return 1 a = read_file_in_array(argv[1]); print a insertion_sort.insertion_sort(a) print a return 0
def test_insertion_sort(): assert (insertion_sort([5, 2, 4, 6, 1, 3]) == [1, 2, 3, 4, 5, 6]) assert (insertion_sort([5, 2, 4, 6]) == [2, 4, 5, 6]) assert (insertion_sort([5, 6, 1, 3]) == [1, 3, 5, 6]) assert (insertion_sort([5, 2, 6, 1]) == [1, 2, 5, 6]) assert (insertion_sort([2, 1]) == [1, 2]) assert (insertion_sort([1, 2]) == [1, 2]) assert (insertion_sort([2, 1, 1, 1, 2, 1, 3]) == [1, 1, 1, 1, 2, 2, 3]) assert (insertion_sort([2, 1, 1, 1, 3, 2, 1]) == [1, 1, 1, 1, 2, 2, 3]) assert (insertion_sort([1]) == [1])
def test_stable_random_3(seq): """Test stability property on random lists with random duplicate values.""" from insertion_sort import insertion_sort if len(seq) < 2: return seq = list(seq) index_a = random.randrange(len(seq) - 1) index_b = random.randrange(index_a + 1, len(seq)) val_a = seq[index_a] val_b = int(val_a) seq[index_b] = val_b insertion_sort(seq) index_a = seq.index(val_a) assert seq[index_a + 1] is val_b
def bucket_sort(array): bucket = [list() for i in range(10)] for i in range(len(array)): bucket[int(array[i] * 10)].append(array[i]) for i in range(len(bucket)): insertion_sort(bucket[i]) m = 0 for i in range(len(bucket)): for j in range(len(bucket[i])): array[m] = bucket[i][j] m += 1
def bucket_sort(v): if not v: return v nb = max(10, len(v) / 10) b = [[] for _ in xrange(nb)] m = max(v) * 1.01 for x in v: b[get_bucket(x / m, nb)].append(x) res = [] # print min([len(x) for x in b]), max([len(x) for x in b]) for i in b: insertion_sort(i) res += i return res
def median(lst, n=5, LEVEL=0): if len(lst) <= n: array = lst[:] insertion_sort.insertion_sort(array) idx = len(array)//2 m = array[idx] # print array, m return m sublists = chunk(lst, n) medians = [median(s) for s in sublists] return median(medians)
def bucketsort(A): """ A must be a list of floats s.t. for all x in A, 0 <= x < 1 >>> bucketsort([0.1, 0.2]) [0.10000000000000001, 0.20000000000000001] >>> bucketsort([0.2, 0.1]) [0.10000000000000001, 0.20000000000000001] >>> bucketsort([]) [] """ n = len(A) B = [[] for j in range(0, n)] C = [] for i in xrange(0, n): j = int(n*A[i]) B[j].append(A[i]) for b in B: insertion_sort.insertion_sort(b) C = C + b return C
def bucket_sort(a): n = len(a) # b is a list of n empty lists # [[]]*n creates copies of same list b = [[] for _ in range(n)] # print(b[0],len(b), n) # b[1].append(5) for i in range(n): # x = int(floor(n*a[i])) # print(b[x]) b[floor(n*a[i])].append(a[i]) # print(b[int(floor(n*a[i]))]) # print(b) # insertion sort to sort in-bucket elements for i in range(n): insertion_sort(b[i]) # flatten b # print(b) flat_sorted = [j for i in b for j in i] return flat_sorted
def test_insertion_sort(): test_list = [randint(1, 50) for i in range(15)] test_sorted = insertion_sort(test_list[:]) if test_sorted == sorted(test_list): print("test passes") print(test_list) print(test_sorted) else: print("test fails") print(test_list) print(test_sorted)
def test_randomly(self): for each_pass in range(0, 1000): random_list = [] for each_number in range(0, random.randint(3, 40)): random_number = random.randint(0, random.randint(1, 1000)) random_list.append(random_number) sorted_random_list = i_s.insertion_sort(random_list) assert len(random_list) == len(sorted_random_list) for each_number in range(0, (len(sorted_random_list) - 1)): assert (sorted_random_list[each_number] <= sorted_random_list[(each_number + 1)])
def test_sort(make_random_lists): random_list = make_random_lists for a_list in random_list: sorted_list = insertion_sort(a_list) for j in range(len(a_list)): if j == 0: continue else: if sorted_list[j] < sorted_list[j-1]: raise ValueError, sorted_list
def merge_insertion_sort(lst, k=2): """ :description: mergesort not in place :time: O(nlogn) this is (intuitively not mathematically) because if you break this problem down into a tree representation of the calls, you see that depth of that tree requires O(n) time and that there are logn depth levels in the tree giving a total run time of O(nlogn) :space: O(n), more precisely O(2n) since at the worst point we have to have double the size of the original list in memory (during the last call to merge) """ if len(lst) <= k: return insertion_sort.insertion_sort(lst) cut = len(lst) / 2 first = merge_insertion_sort(lst[:cut]) second = merge_insertion_sort(lst[cut:]) return merge(first, second)
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_input(): # Checks that it needs a list with pytest.raises(TypeError): insertion_sort() d = {1: 'one', 2: 'two'} with pytest.raises(KeyError): insertion_sort(d) with pytest.raises(TypeError): insertion_sort(None)
def test_predictably(self): dict_of_lists = { 'list_zero': [0, 0, 0, 0, 0, 0, 0, 0], 'list_one': [0, 0, 0, 0, 1, 1, 1, 1], 'list_two': [0, 1, 0, 1, 0, 1, 0, 1], 'list_three': [0, 1, 1, 0, 1, 1, 0, 0], 'list_four': [10, 100, 1000000, 10000, 1, 100000, 0, 1000], 'list_five': [0001, 0010, 0100, 1000, 1100, 0011, 0101, 0110], } for each_key in dict_of_lists: each_list = dict_of_lists[each_key] sorted_list = i_s.insertion_sort(each_list) assert len(sorted_list) == len(each_list) for each_number in range(0, (len(each_list) - 1)): assert (sorted_list[each_number] <= sorted_list[(each_number + 1)])
def test_general_case(self): arr = [3, 2, 6, 5, 1, 4] self.assertEqual(insertion_sort(arr), [1, 2, 3, 4, 5, 6])
def test_empty_list(self): arr = [] self.assertEqual(insertion_sort(arr), [])
def test_singleton_list(self): arr = [5] self.assertEqual(insertion_sort(arr), [5])