Python 数组排序

Python是一种高级编程语言，内置了丰富的数据结构和算法，支持多种排序算法来对数组进行排序。在本文中，我们将介绍Python中的数组排序及其应用。

数组排序算法

Python中的数组排序算法包括以下几种：

1. 冒泡排序
2. 插入排序
3. 选择排序
4. 快速排序
5. 归并排序
6. 堆排序

下面将分别介绍这些排序算法的思想和实现方法。

冒泡排序

冒泡排序是一种简单的排序算法，它重复地遍历数组，比较相邻的两个元素，如果它们的顺序错误就交换它们的位置。重复遍历直至排序完成。

def bubble_sort(arr):
    n = len(arr)
    for i in range(n-1):
        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

插入排序

插入排序是一种简单的排序算法，它从第二个元素开始遍历数组，将当前元素插入到已经排好序的前面序列中从后往前寻找第一个比它大的元素的后面。

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

选择排序

选择排序是一种简单的排序算法，它重复地遍历数组，找到未排序部分中的最小元素，将其放到已排序部分的末尾。重复遍历直至排序完成。

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

快速排序

快速排序是一种分治的排序算法，它选择一个枢轴元素，将小于枢轴元素的放到枢轴元素左边，大于枢轴元素的放到枢轴元素右边，然后对左右两个部分递归地进行排序。

def quick_sort(arr):
    n = len(arr)
    if n <= 1:
        return arr
    else:
        pivot = arr[n//2]
        left = [x for x in arr if x < pivot]
        middle = [x for x in arr if x == pivot]
        right = [x for x in arr if x > pivot]
        return quick_sort(left) + middle + quick_sort(right)

归并排序

归并排序是一种分治的排序算法，它将一个序列分成两个子序列，对每个子序列进行递归排序，然后将两个已经排好序的子序列合并成一个有序序列。

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

def merge(left, right):
    result = []
    i, j = 0, 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result += left[i:]
    result += right[j:]
    return result

堆排序

堆排序是一种利用堆这种数据结构的排序算法，它将待排序的序列构造成一个大根堆或小根堆，然后将堆顶元素与末尾元素交换，再重新对剩余元素进行堆调整，直到排序完成。

def heap_sort(arr):
    def heapify(arr, n, i):
        largest = i
        l = 2 * i + 1
        r = 2 * i + 2
  
        if l < n and arr[i] < 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

代码示例

下面是使用上述算法进行排序的示例，供读者参考：

arr = [64, 34, 25, 12, 22, 11, 90]

print('Bubble sort: ', bubble_sort(arr[:]))
print('Insertion sort: ', insertion_sort(arr[:]))
print('Selection sort: ', selection_sort(arr[:]))
print('Quick sort: ', quick_sort(arr[:]))
print('Merge sort: ', merge_sort(arr[:]))
print('Heap sort: ', heap_sort(arr[:]))

输出结果：

Bubble sort:  [11, 12, 22, 25, 34, 64, 90]
Insertion sort:  [11, 12, 22, 25, 34, 64, 90]
Selection sort:  [11, 12, 22, 25, 34, 64, 90]
Quick sort:  [11, 12, 22, 25, 34, 64, 90]
Merge sort:  [11, 12, 22, 25, 34, 64, 90]
Heap sort:  [11, 12, 22, 25, 34, 64, 90]

结论

Python中内置了多种排序算法，根据不同场合可以选择不同的算法进行排序，例如：

• 对于大数据集且需要高效率时，选择快速排序或堆排序。
• 对于小数据集且需要稳定性时，选择插入排序、冒泡排序或归并排序。

除此之外，还有许多其他的排序算法，读者可以根据实际需求选择适合的排序算法。