def shaker_sort(array):
print("[log] run shaker_sort")
method = "shaker sort"
count = 0
l = 0
r = len(array) - 1
while l < r:
for i in range(l, r):
if array[i] > array[i + 1]:
array[i], array[i + 1] = array[i + 1], array[i]
shift = i
gi.make_image(array, count, method, i, -1)
count += 1
r = shift
for i in range(r, l, -1):
if array[i] < array[i - 1]:
array[i], array[i - 1] = array[i - 1], array[i]
shift = i
gi.make_image(array, count, method, i, -1)
count += 1
l = shift
gi.make_endimage(array, count, method)
def msd_radix(array, l, r, count, method, N=2):
work = array[:]
if r - l <= 10:
print(r - l)
array, count = msd_insert(array, l, r, count, method)
else:
C = [0] * 257
shift = N * 2
for i in range(l, r + 1):
C[(array[i] >> shift) & 0xff] += 1
#print("{0:02o} {0:08b} {1:08b}".format(array[i],(array[i] >> shift)))
for i in range(1, 257):
C[i] += C[i - 1]
for i in range(l, r - 1, -1):
j = (array[i] >> shift) & 0xff
C[j] -= 1
work[C[j] + l] = array[i]
for i in range(l, r + 1):
array[i] = work[i]
gi.make_image(array, count, method, -1, -1)
count += 1
if N > 0:
C[256] = r - l + 1
for i in range(0, 256):
L = l + C[i]
R = l + C[i + 1] - 1
if L < R:
array, count = msd_radix(array, L, R, count, method, N - 1)
return array, count
def lsd_radix_sort(array):
print("[log] run LSD radix sort")
method = "radix sort (LSD)"
count = 0
r = 10
m = 1
rad = array[:]
y = array[:]
while m <= r:
for i in range(len(array)):
rad[i] = (array[i] // m) % 10
k = 0
for i in range(10):
for j in range(len(array)):
if rad[j] == i:
y[k] = array[j]
k += 1
for i in range(len(array)):
array[i] = y[i]
gi.make_image(array, count, method, i, -1)
count += 1
m *= 10
gi.make_endimage(array, count, method)
def msd_insert(array, l, r, count, method):
for i in range(l, r - 1):
m = i
for j in range(i + 1, r):
if array[m] > array[j]:
m = j
gi.make_image(array, count, method, i, m)
count += 1
array[m], array[i] = array[i], array[m]
return array, count
def selection_sort(array):
print("[log] run selection sort")
method = "selection sort"
count = 0
n = len(array)
for i in range(n - 1):
least = i
for j in range(i + 1, n):
if array[j] < array[least]:
least = j
gi.make_image(array, count, method, j, least)
count += 1
#sys.exit()
array[i], array[least] = array[least], array[i]
gi.make_endimage(array, count, method)
def bubble_sort(array):
print("[log] run bubble sort")
method = "bubble sort"
count = 0
n = len(array)
for i in range(0, n):
rev = range(i, n)
for j in reversed(rev):
if array[j - 1] > array[j]:
temp = array[j - 1]
array[j - 1] = array[j]
array[j] = temp
gi.make_image(array, count, method, j - 1, -1)
count += 1
gi.make_endimage(array, count, method)
def gravity_sort(arr):
print("[log] run gravity sort")
method = "gravity sort"
count = 0
mat = arrtomat(arr)
x = array.array('i')
while mat != x:
gi.make_image(arr, count, method, -1, -1)
count += 1
x = mat
mat = gravity(mat)
arr = mattoarr(mat)
gi.make_endimage(arr, count, method)
def gnome_sort(array):
print("[log] run gnome sort")
method = "gnome sort"
count = 0
gnome = 1
while gnome < len(array):
if gnome >= 1 and array[gnome - 1] > array[gnome]:
array[gnome], array[gnome - 1] = array[gnome - 1], array[gnome]
gnome -= 1
else:
gnome += 1
gi.make_image(array, count, method, gnome - 1, -1)
count += 1
gi.make_endimage(array, count, method)
def stooge(array, count, m, l, r):
if array[l] > array[r]:
array[l], array[r] = array[r], array[l]
t = (r - l + 1) // 3
if t < 1:
return array, count
array, count = stooge(array, count, m, l, r - t)
array, count = stooge(array, count, m, l + t, r)
array, count = stooge(array, count, m, l, r - t)
gi.make_image(array, count, m, l, r)
count += 1
return array, count
def comb_sort(array):
print("[log] run comb sort")
method = "comb sort"
count = 0
h = len(array)
f = False
while (h > 1 or f):
h = (h * 10) // 13
f = False
for i in range(len(array) - h):
if array[i] > array[i + h]:
array[i], array[i + h] = array[i + h], array[i]
gi.make_image(array, count, method, i, i + h)
count += 1
gi.make_endimage(array, count, method)
def insertion_sort(array):
print("[log] run insertion sort")
method = "insertion sort"
count = 0
n = len(array)
for i in range(1, n):
tmp = array[i]
if tmp < array[i - 1]:
j = i
while True:
array[j] = array[j - 1]
gi.make_image(array, count, method, j, -1)
count += 1
j -= 1
if j <= 0 or tmp >= array[j - 1]:
break
array[j] = tmp
#sys.exit()
gi.make_endimage(array, count, method)
def downheap(array, count, m, root, bot):
l = root * 2 + 1
r = root * 2 + 2
if l <= bot and array[l] > array[root]:
maxch = l
else:
maxch = root
if r <= bot and array[r] > array[maxch]:
maxch = r
if maxch != root:
array[root], array[maxch] = array[maxch], array[root]
array, count = downheap(array, count, m, maxch, bot)
gi.make_image(array, count, m, root, maxch)
count += 1
return array, count
def oddeven_sort(array):
print("[log] run oddeven sort")
method = "oddeven sort"
count = 0
ischange = True
while ischange:
ischange = False
for i in range(0, len(array) - 1, 2):
if array[i] > array[i + 1]:
array[i], array[i + 1] = array[i + 1], array[i]
ischange = True
gi.make_image(array, count, method, i, i + 1)
count += 1
for i in range(1, len(array) - 1, 2):
if array[i] > array[i + 1]:
array[i], array[i + 1] = array[i + 1], array[i]
ischange = True
gi.make_image(array, count, method, i, i + 1)
count += 1
gi.make_endimage(array, count, method)
def shell_sort(array):
print("[log] run shell sort")
method = "shell sort"
count = 0
inc = 4
while inc > 0:
for i in range(len(array)):
j = i
temp = array[i]
while j >= inc and array[j - inc] > temp:
array[j] = array[j - inc]
j = j - inc
array[j] = temp
gi.make_image(array, count, method, i, -1)
count += 1
if inc // 2 != 0:
inc = inc // 2
elif inc == 1:
inc = 0
else:
inc = 1
gi.make_endimage(array, count, method)
def quick(array, l, r, count, m):
p = array[l]
lh = l
rh = r
while l < r:
while array[r] >= p and l < r:
r -= 1
if l != r:
array[l] = array[r]
l += 1
gi.make_image(array, count, m, l, r)
count += 1
while array[l] <= p and l < r:
l += 1
if l != r:
array[r] = array[l]
r -= 1
gi.make_image(array, count, m, l, r)
count += 1
array[l] = p
p = l
l = lh
r = rh
if l < p:
array, count = quick(array, l, p - 1, count, m)
if r > p:
array, count = quick(array, p + 1, r, count, m)
return array, count
def merge(array, l, r, count, m):
if r - l < 1:
return array, count
mid = (l + r) // 2
merged = array[:]
array, count = merge(array, l, mid, count, m)
array, count = merge(array, mid + 1, r, count, m)
merged = array[:]
i = l
j = mid + 1
while l <= mid and j <= r:
if (array[l] <= array[j]):
merged[i] = array[l]
l += 1
else:
merged[i] = array[j]
j += 1
i += 1
gi.make_image(merged, count, m, i - 1, -1)
count += 1
while l <= mid:
merged[i] = array[l]
i += 1
l += 1
gi.make_image(merged, count, m, i - 1, -1)
count += 1
while j <= r:
merged[i] = array[j]
i += 1
j += 1
gi.make_image(merged, count, m, i - 1, -1)
count += 1
return merged[:], count
