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:
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:
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 _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:
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:
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 _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 _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 _do_sort(self, data: data_store) -> None:
self.__merge_sort(data, 0, data.size() - 1)