def __insertion_sort__(self, data: data_store, start: int, end: int): for i in range(start, end): src_index = i for j in range(0, i): if data.is_less_than(src_index, j): data.move(src_index, j) break
def _do_sort(self, data: data_store) -> None: size = data.size() for i in range(size // 2 - 1, -1, -1): self._heapify(data, size, i) for i in range(size - 1, 0, -1): data.swap(i, 0) self._heapify(data, i, 0)
def _do_sort(self, data: data_store) -> None: for i in range(1, data.size()): src_index = i for j in range(0, i): if data.is_less_than(src_index, j): data.move(src_index, j) break
def radix_sort(self, data: data_store, exp: int) -> bool: changed = False for i in range(0, data.size() - 1): if self.is_greater_than(data, exp, i, i + 1): data.swap(i, i + 1, skip_draw=True) changed = True data.draw() return changed
def _do_sort(self, data: data_store) -> None: for i in range(data.size()): min_index = i for j in range(i + 1, data.size()): if data.is_greater_than(min_index, j): min_index = j if not i == min_index: data.swap(min_index, i)
def _do_sort(self, data: data_store) -> None: curr_size = data.size() while curr_size > 1: max_index = self.__find_max(data, curr_size) if max_index != curr_size - 1: self.__flip(data, max_index) self.__flip(data, curr_size - 1) data.draw() curr_size -= 1
def sort(self, data: data_store) -> None: print('Starting sort "{}" with {} items'.format( self.name(), data.size())) data.init(self.name()) start = datetime.datetime.now() self._do_sort(data) end = datetime.datetime.now() print('\tDone in {}'.format(end - start)) data.draw()
def __partition(self, data: data_store, low: int, high: int) -> None: pivot_index = random.randint(low, high) data.swap(pivot_index, low) pivot_index = low for j in range(low + 1, high + 1): if data.is_less_than(j, pivot_index): data.move(j, pivot_index) pivot_index += 1 return pivot_index
def _do_sort(self, data: data_store) -> None: size = data.size() gap = size swapped = True while gap != 1 or swapped: gap = self.__get_next_gap__(gap) swapped = False for i in range(0, size - gap): if data[i] > data[i + gap]: data.swap(i, i + gap) swapped = True
def __merge(self, data: data_store, start: int, mid: int, end: int) -> None: start2 = mid + 1 if (data[mid] <= data[start2]): return while start <= mid and start2 <= end: if data.is_less_than(start, start2): start += 1 else: data.move(start2, start) start += 1 mid += 1 start2 += 1
def _do_sort(self, data: data_store) -> None: n = data.size() interval = n // 2 while interval > 0: for i in range(interval, n): temp = data[i] j = i while j >= interval and data[j - interval] > temp: data.set(j, data[j - interval], skip_draw=True) # data[j] = data[j - interval] j -= interval data[j] = temp interval //= 2
def _heapify(self, data: data_store, size: int, root: int) -> None: largest = root left = (2 * root) + 1 right = (2 * root) + 2 if left < size and data[largest] < data[left]: largest = left if right < size and data[largest] < data[right]: largest = right if largest != root: data.swap(root, largest) self._heapify(data, size, largest)
def _do_sort(self, data: data_store) -> None: max = data.max() exp = 1 while int(max / exp) > 0: while self.radix_sort(data, exp): pass exp *= 10
def _do_sort(self, data: data_store) -> None: bucket_size = 50 num_buckets = int(data.size() / bucket_size) if num_buckets == 0: self.__insertion_sort__(data, 0, data.size()) return bucket_sizes = [0] * num_buckets for i in range(data.size()): bucket_idx = int(data[i] / bucket_size) dest_idx = sum(bucket_sizes[0:bucket_idx + 1]) data.move(i, dest_idx) bucket_sizes[bucket_idx] += 1 for i in range(num_buckets - 1, -1, -1): start = sum(bucket_sizes[0:i]) end = start + bucket_sizes[i] self.__insertion_sort__(data, start, end)
def _do_sort(self, data: data_store) -> None: sorted = False while not sorted: sorted = True for i in range(data.size() - 1): if data.is_greater_than(i, i + 1): data.swap(i, i + 1, skip_draw=True) sorted = False data.draw()
def _do_sort(self, data: data_store) -> None: index = 0 found = False while index < data.size(): if index == 0: index += 1 if found: data.draw() found = False elif data.is_greater_than_or_equal(index, index - 1): index += 1 if found: data.draw() found = False else: data.swap(index, index - 1, skip_draw=True) index -= 1 found = True
def __find_max(self, data: data_store, size: int) -> int: max_index = 0 for i in range(0, size): if data.is_greater_than(i, max_index): max_index = i return max_index
def __flip(self, data: data_store, end: int) -> None: start = 0 while start < end: data.swap(start, end, skip_draw=True) start += 1 end -= 1
def _do_sort(self, data: data_store) -> None: self.__merge_sort(data, 0, data.size() - 1)