if lo < hi:

pivot = partition(arr, lo, hi)

quick_sort_rec(arr, lo, pivot - 1)

# choose pivot by median-of-three

x, idx = sorted(((arr[lo], lo), (arr[hi], hi), (arr[lo + hi >> 1], lo + hi >> 1)))[1]

arr[lo], arr[idx] = arr[idx], arr[lo]

while lo < hi:

while lo < hi and arr[hi] >= x:

hi -= 1

arr[lo] = arr[hi]

while lo < hi and arr[lo] <= x:

lo += 1

arr[hi] = arr[lo]

arr[lo] = x

if first < last:

mid = (first + last) // 2

merge_sort_rec(arr, first, mid, temp)

merge_sort_rec(arr, mid + 1, last, temp)

i, j = first, mid + 1

m, n = mid, last

k = 0

while i <= m and j <= n:

if arr[i] <= arr[j]:

temp[k] = arr[i]

i += 1

else:

temp[k] = arr[j]

j += 1

k += 1

while i <= m:

temp[k] = arr[i]

i += 1

k += 1

while j <= n:

temp[k] = arr[j]

j += 1

k += 1

for i in range(k):

if len(arr) <= 1:

return arr

mid = len(arr) // 2

left = merge_sort_rec2(arr[:mid])

right = merge_sort_rec2(arr[mid:])

res = []

i = j = 0

while i < len(left) and j < len(right):

if left[i] <= right[j]:

res.append(left[i])

i += 1

else:

res.append(right[j])

j += 1

while i < len(left):

res.append(left[i])

i += 1

while j < len(right):

res.append(right[j])

j += 1

res = []

while left and right:

if left[0] <= right[0]:

res.append(left.pop(0))

else:

res.append(right.pop(0))

res = []

while left and right:

if left[-1] > right[-1]:

res.insert(0, left.pop())

else:

res.insert(0, right.pop())

for i in range(1, len(arr)):

x = arr[i]

j = i - 1

while j >= 0 and arr[j] > x:

arr[j + 1] = arr[j]

j = j - 1

for i in range(len(arr) - 1):

for j in range(len(arr) - i - 1):

if arr[j] > arr[j + 1]:

i = len(arr) - 1

while i > 0:

last_swap = 0

for j in range(i):

if arr[j] > arr[j + 1]:

arr[j], arr[j + 1] = arr[j + 1], arr[j]

last_swap = j

# if last_swap=0, it means no swap in last round, end sort

# [last_swap, i] has been sorted, start from last_swap

for i in range(len(arr)):

min_i = i

for j in range(i+1, len(arr)):

if arr[j] < arr[min_i]:

min_i = j

# build max heap

for i in range(len(arr) // 2)[::-1]:

heap_adjust(arr, i, len(arr))

# adjust from last element

for i in range(1, len(arr))[::-1]:

# swap first with the last, make the right most is maximum

arr[0], arr[i] = arr[i], arr[0]

cur = arr[i]

while 2 * i + 1 < n:

# get child index in heap

child = 2 * i + 1

# choose the larger child

if child < n - 1 and arr[child + 1] > arr[child]:

child += 1

# if child is larger than parent, sift up

if cur < arr[child]:

arr[i], arr[child] = arr[child], cur

i = child

else:

# Shell sort using Shell's (original) gap sequence: n/2, n/4, ..., 1.

gap = len(arr) // 2

# loop over the gaps

while gap > 0:

# do the insertion sort

for i in range(gap, len(arr)):

val = arr[i]

j = i

while j >= gap and arr[j - gap] > val:

arr[j] = arr[j - gap]

j -= gap

arr[j] = val

min_val, max_val = min(arr), max(arr)

size = max_val - min_val + 1

counter = [0] * size

for i in range(len(arr)):

counter[arr[i] - min_val] += 1

idx = 0

for i, v in enumerate(counter):

# use slice assignment

arr[idx:idx + v] = [i + min_val] * v

min_val, max_val = min(arr), max(arr)

# initialize buckets

count = (max_val - min_val) // size + 1

buckets = [[] for _ in range(count)]

# put values in buckets

for i in range(len(arr)):

buckets[(arr[i] - min_val) // size].append(arr[i])

# sort buckets and place back into input array

i = 0

for bucket in buckets:

insert_sort(bucket)

# use slice assignment

arr[i:i + len(bucket)] = bucket

# get hash codes

code = hashing(arr)

buckets = [[] for _ in range(code[1])]

# distribute data into buckets: O(n)

for i in arr:

x = re_hashing(i, code)

buckets[x].append(i)

i = 0

# merge the buckets: O(n)

for bucket in buckets:

insert_sort(bucket)

arr[i:i + len(bucket)] = bucket

radix = 10

max_length = False

placement = 1

while not max_length:

max_length = True

# declare and initialize buckets

buckets = [[] for _ in range(radix)]

# split arr between lists

for i in arr:

temp = i // placement

buckets[temp % radix].append(i)

if max_length and temp > 0:

max_length = False

# assign from bucket to arr

i = 0

for bucket in buckets:

insert_sort(bucket)

# use slice assignment

arr[i:i + len(bucket)] = bucket

i += len(bucket)

# move to next digit

placement *= radix

order, enter, state = deque(), set(graph), {}

def dfs(node):

state[node] = GRAY

for k in graph.get(node, ()):

sk = state.get(k, None)

if sk == GRAY:

raise ValueError("cycle")

if sk == BLACK:

continue

enter.discard(k)

dfs(k)

order.appendleft(node)

state[node] = BLACK

while enter:

dfs(enter.pop())

start = time.time()

for _ in range(100):

nums = [random.randrange(1, 250) for _ in range(1000)]

nums1 = sorted(nums)

sort_func(nums)

if nums1 != nums:

print('incorrect', )

end = time.time()