Как отсортировать огромный список чисел

import numpy as np
from random import randint
n = int(1e10)
#a = [randint(-128, 127) for i in range(n)]
#a = np.array(a)
a = np.random.randint(-128, 127, (n), dtype = np.int8)
np.sort(a)
print(a[543687653])

from random import randint
from timeit import repeat
 
 
def run_sorting_algorithm(algorithm, array):
 
    setup_code = f"from __main__ import {algorithm}" \
        if algorithm != "sorted" else ""
 
    stmt = f"{algorithm}({array})"
 
    times = repeat(setup=setup_code, stmt=stmt, repeat=3, number=10)
 
    print(f"Algorithm: {algorithm}. Minimum execution time: {min(times)}")
 
 
def bubble_sort(array):
    n = len(array)
    for i in range(n):
        already_sorted = True
        for j in range(n - i - 1):
            if array[j] > array[j + 1]:
                array[j], array[j + 1] = array[j + 1], array[j]
                already_sorted = False
        if already_sorted:
            break
        return array
 
 
def insertion_sort(array):
    for i in range(1, len(array)):
        key_item = array[i]
        j = i - 1
        while j >= 0 and array[j] > key_item:
            array[j + 1] = array[j]
            j -= 1
        array[j + 1] = key_item
    return array
 
 
def merge(left, right):
    if len(left) == 0:
        return right
    if len(right) == 0:
        return left
    result = []
    index_left = index_right = 0
    while len(result) < len(left) + len(right):
        if left[index_left] <= right[index_right]:
            result.append(left[index_left])
            index_left += 1
        else:
            result.append(right[index_right])
            index_right += 1
        if index_right == len(right):
            result += left[index_left:]
            break
        if index_left == len(left):
            result += right[index_right:]
            break
 
    return result
 
 
def merge_sort(array):
    if len(array) < 2:
        return array
    midpoint = len(array) // 2
 
    return merge(left=merge_sort(array[:midpoint]), right=merge_sort(array[midpoint:]))
 
 
def quicksort(array):
    if len(array) < 2:
        return array
    low, same, high = [], [], []
    pivot = array[randint(0, len(array) - 1)]
    for item in array:
        if item < pivot:
            low.append(item)
        elif item == pivot:
            same.append(item)
        elif item > pivot:
            high.append(item)
    return quicksort(low) + same + quicksort(high)
 
 
def insertion_sort2_for_time_sort(array, left=0, right=None):
    if right is None:
        right = len(array) - 1
    for i in range(left + 1, right + 1):
        key_item = array[i]
        j = i - 1
        while j >= left and array[j] > key_item:
            array[j + 1] = array[j]
            j -= 1
        array[j + 1] = key_item
 
    return array
 
 
def timsort(array):
    min_run = 32
    n = len(array)
    for i in range(0, n, min_run):
        insertion_sort2_for_time_sort(array, i, min((i + min_run - 1), n - 1))
    size = min_run
    while size < n:
        for start in range(0, n, size * 2):
            midpoint = start + size - 1
            end = min((start + size * 2 - 1), (n-1))
            merged_array = merge(
                left=array[start:midpoint + 1],
                right=array[midpoint + 1:end + 1])
            array[start:start + len(merged_array)] = merged_array
        size *= 2
 
    return array
 
 
def heapify(nums, heap_size, root_index):
    largest = root_index
    left_child = (2 * root_index) + 1
    right_child = (2 * root_index) + 2
    if left_child < heap_size and nums[left_child] > nums[largest]:
        largest = left_child
    if right_child < heap_size and nums[right_child] > nums[largest]:
        largest = right_child
    if largest != root_index:
        nums[root_index], nums[largest] = nums[largest], nums[root_index]
        heapify(nums, heap_size, largest)
 
 
def heap_sort(nums):
    n = len(nums)
    for i in range(n, -1, -1):
        heapify(nums, n, i)
    for i in range(n - 1, 0, -1):
        nums[i], nums[0] = nums[0], nums[i]
        heapify(nums, i, 0)
 
 
def partition(nums, low, high):
    pivot = nums[(low + high) // 2]
    i = low - 1
    j = high + 1
    while True:
        i += 1
        while nums[i] < pivot:
            i += 1
        j -= 1
        while nums[j] > pivot:
            j -= 1
        if i >= j:
            return j
        nums[i], nums[j] = nums[j], nums[i]
 
 
def quick_sort2(nums):
    def _quick_sort(items, low, high):
        if low < high:
            split_index = partition(items, low, high)
            _quick_sort(items, low, split_index)
            _quick_sort(items, split_index + 1, high)
    _quick_sort(nums, 0, len(nums) - 1)
 
 
def shell_sort(input_list):
    gap = len(input_list) // 2
    while gap > 0:
        for i in range(gap, len(input_list)):
            temp = input_list[i]
            j = i
            while j >= gap and input_list[j - gap] > temp:
                input_list[j] = input_list[j - gap]
                j = j - gap
            input_list[j] = temp
 
        gap = gap // 2
 
 
ARRAY_LENGTH = 1000
array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
run_sorting_algorithm("sorted", array)
run_sorting_algorithm("bubble_sort", array)
run_sorting_algorithm("merge_sort", array)
run_sorting_algorithm("quicksort", array)
run_sorting_algorithm("timsort", array)
run_sorting_algorithm("heap_sort", array)
run_sorting_algorithm("quick_sort2", array)
run_sorting_algorithm("shell_sort", array)
run_sorting_algorithm("insertion_sort", array)