GATE-CS-2015（套装1）- 问题 20

这道问题是关于排序算法的。给定 $n$ 个整数 $a_i$，请按升序对它们进行排序。下面是几个常用的排序算法。

冒泡排序

冒泡排序是一种简单的排序算法，它每次比较相邻的两个数，将较大的数向右移动。因此在每次遍历时，最大的数总是被移动到了右边。时间复杂度为 $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 selection_sort(arr):
    n = len(arr)
    for i in range(n):
        min_idx = i
        for j in range(i+1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    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(n\log n)$，最坏情况下为 $O(n^2)$。

def quick_sort(arr, start, end):
    if start < end:
        pivot = partition(arr, start, end)
        quick_sort(arr, start, pivot - 1)
        quick_sort(arr, pivot + 1, end)
    return arr

def partition(arr, start, end):
    pivot = arr[end]
    i = start - 1
    for j in range(start, end):
        if arr[j] <= pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i + 1], arr[end] = arr[end], arr[i + 1]
    return i + 1

除了这些常用的排序算法，还有归并排序、堆排序等。在实际开发中，我们需要根据实际情况选择不同的排序算法，来完成排序任务。