对整数流进行排序

当我们需要对整数流进行排序时，我们可以采用不同的排序算法。排序算法的选择取决于输入数据的大小、数据类型、内存使用限制以及排序的目的等因素。下面是一些常用的排序算法及其适用场景。

冒泡排序

冒泡排序是一种基础的排序算法，在小数据量情况下表现良好。其时间复杂度为O(n^2)，空间复杂度为O(1)。其基本思想是通过多次遍历输入数据，在每次遍历中比较相邻的两个元素，如果它们的顺序不正确，则交换它们的位置。通过这样的方式，每次遍历都会把未排序中最大的元素交换到正确的位置。

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

插入排序

插入排序是一种简单而有效的排序算法，其时间复杂度为O(n^2)，空间复杂度为O(1)。其基本思想是将未排序的数据一个个地插入到已排序的序列中，直到所有数据都插入到正确的位置。

def insertion_sort(arr):
    n = len(arr)
    for i in range(1, n):
        j = i - 1
        key = arr[i]
        while j >= 0 and arr[j] > key:
            arr[j+1] = arr[j]
            j -= 1
        arr[j+1] = key
    return arr

快速排序

快速排序是一种常用的排序算法，其时间复杂度为O(nlogn)。其基本思想是选择一个中间值作为基准值，将待排序数据分成左右两个部分，将小于基准值的元素放到左边，将大于基准值的元素放到右边，然后递归地对左右两个部分进行排序。

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr)//2]
    left, right, equal = [], [], []
    for x in arr:
        if x < pivot:
            left.append(x)
        elif x > pivot:
            right.append(x)
        else:
            equal.append(x)
    return quick_sort(left) + equal + quick_sort(right)

归并排序

归并排序是一种分治排序算法，其时间复杂度为O(nlogn)。其基本思想是将待排序数据分成两个部分，递归地对两个部分进行排序，然后对排好序的两个部分进行归并。

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)
    
def merge(left, right):
    res = []
    i, j = 0, 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
    res += left[i:]
    res += right[j:]
    return res

堆排序

堆排序是一种不稳定的排序算法，其时间复杂度为O(nlogn)。其基本思想是将待排序数据看作完全二叉树的结构，将其构建成一个大根堆，并不断地将根节点与最后一个节点交换位置，再对前面的部分重新构建大根堆。

def heap_sort(arr):
    def heapify(arr, n, i):
        largest = i
        l = 2 * i + 1
        r = 2 * i + 2
        if l < n and arr[largest] < arr[l]:
            largest = l
        if r < n and arr[largest] < arr[r]:
            largest = r
        if largest != i:
            arr[i], arr[largest] = arr[largest], arr[i]
            heapify(arr, n, largest)
    n = len(arr)
    for i in range(n//2-1, -1, -1):
        heapify(arr, n, i)
    for i in range(n-1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]
        heapify(arr, i, 0)
    return arr

以上是几种常用的排序算法，我们可以根据实际需求选择合适的算法对整数流进行排序。