如何对集合进行排序？

在编程中，经常需要对集合进行排序，这可以帮助我们更方便地查找和处理集合中的数据。下面介绍一些常见的排序方法。

冒泡排序

冒泡排序是最简单的排序方法之一，它的原理是比较相邻的元素，根据大小进行交换。冒泡排序的时间复杂度为 O(n^2)。

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)。

def insertion_sort(arr):
    n = len(arr)
    for i in range(1, n):
        key = arr[i]
        j = i - 1
        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.pop()
    left, right = [], []
    for i in arr:
        if i <= pivot:
            left.append(i)
        else:
            right.append(i)
    return quick_sort(left) + [pivot] + quick_sort(right)

归并排序

归并排序是一种分治的排序算法，它的基本思想是将原始数组划分成较小的数组，直到每个小数组只有一个位置，接着将小数组归并成较大的数组，直到最后只有一个完整的数组。归并排序的时间复杂度为 O(nlogn)。

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left, right = arr[:mid], arr[mid:]
    return merge(merge_sort(left), merge_sort(right))

def merge(left, right):
    result = []
    while left and right:
        if left[0] <= right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
    if left:
        result.extend(left)
    if right:
        result.extend(right)
    return result

以上是几种常见的排序方法，根据实际需求选择合适的方法进行排序。