任意整数N个元素数组排序

常见的数组排序算法有冒泡排序、插入排序、选择排序、快速排序、归并排序等等。下面我分别介绍一下这几种排序算法的实现。

1. 冒泡排序

冒泡排序是一种比较简单的排序算法，它的基本思想是通过相邻元素之间的比较和交换来实现排序。

具体实现步骤如下：

1. 从数组的第一个元素开始，依次比较相邻的两个元素，如果前一个元素比后一个元素大，则交换两个元素的位置，这样一轮下来，最大的元素就会被移动到数组的最后。

2. 对剩余的元素重复上述步骤，直到所有元素都被排序。

下面是冒泡排序的代码实现：

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

2. 插入排序

插入排序的基本思想是将一个元素插入到已经排好序的数组中，使得插入后的数组仍然有序。

具体实现步骤如下：

1. 将数组的第一个元素视为已经排好序的数组。

2. 遍历剩余的元素，将每个元素插入到已经排好序的数组中的合适位置。

3. 重复上述步骤，直到所有元素都被排序。

下面是插入排序的代码实现：

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

3. 选择排序

选择排序的基本思想是每次从未排序的部分中选出最小（或最大）的元素，将其与未排序部分的第一个元素交换位置，从而得到一个新的已排序部分。

具体实现步骤如下：

1. 遍历数组，依次找出最小的元素。

2. 将最小的元素与未排序部分的第一个元素交换位置。

3. 重复上述步骤，直到所有元素都被排序。

下面是选择排序的代码实现：

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

4. 快速排序

快速排序是一种基于分治思想的排序算法，它的基本思想是通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，然后再按照此方法对这两部分记录分别进行快速排序，直到整个序列有序。

具体实现步骤如下：

1. 选择一个基准元素，通常选择第一个元素。

2. 将所有小于基准元素的元素放到基准元素的左边，将所有大于基准元素的元素放到基准元素的右边，同时基准元素所在的位置也就确定了。

3. 递归地对基准元素左边和右边的子序列进行快速排序。

下面是快速排序的代码实现：

def quick_sort(arr, left, right):
    if left < right:
        pivot = partition(arr, left, right)
        quick_sort(arr, left, pivot-1)
        quick_sort(arr, pivot+1, right)

def partition(arr, left, right):
    pivot = arr[left]
    while left < right:
        while left < right and arr[right] >= pivot:
            right -= 1
        arr[left] = arr[right]
        while left < right and arr[left] <= pivot:
            left += 1
        arr[right] = arr[left]
    arr[left] = pivot
    return left

5. 归并排序

归并排序是一种基于分治思想的排序算法，它的基本思想是将待排记录分割成若干个子序列，每个子序列都是有序的，然后再将这些有序的子序列合并成一个有序的序列。

具体实现步骤如下：

1. 将待排记录分成两个子序列，每个子序列继续递归地进行归并排序。

2. 将两个子序列合并成一个有序的序列。

3. 重复上述步骤，直到所有元素都被排序。

下面是归并排序的代码实现：

def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_arr = arr[:mid]
        right_arr = arr[mid:]
        merge_sort(left_arr)
        merge_sort(right_arr)
        i = j = k = 0
        while i < len(left_arr) and j < len(right_arr):
            if left_arr[i] < right_arr[j]:
                arr[k] = left_arr[i]
                i += 1
            else:
                arr[k] = right_arr[j]
                j += 1
            k += 1
        while i < len(left_arr):
            arr[k] = left_arr[i]
            i += 1
            k += 1
        while j < len(right_arr):
            arr[k] = right_arr[j]
            j += 1
            k += 1

以上就是几种常见的数组排序算法的实现。需要注意的是，不同的排序算法在不同的场景下可能会有不同的表现，因此在实际应用中需要根据具体情况选择合适的排序算法。