插入排序

插入排序是一种简单直观的排序算法。它的基本思想是将待排序的数据分成已排序和未排序两部分，每次从未排序部分选择一个元素插入到已排序部分的合适位置，直到未排序部分为空。

插入排序是一种简单直观的排序算法，它的基本思想是将一个元素插入到已排序好的序列中的适当位置。

典例： 假设要对数组 [5, 2, 4, 6, 1, 3] 进行排序。

首先，我们将第一个元素 5 视为已排序的序列，因为只有一个元素。

接下来，我们从第二个元素 2 开始，将它插入到已排序序列中的正确位置。由于 2 小于 5，所以我们将 2 插入到第一个位置，得到序列 [2, 5, 4, 6, 1, 3]。

然后，我们继续处理下一个元素 4。我们将 4 与已排序序列中的元素依次比较，发现它应该插入到第二个位置，得到序列 [2, 4, 5, 6, 1, 3]。

接下来，我们继续处理下一个元素 6。由于 6 大于 5，所以它应该位于已排序序列的最后一个位置，得到序列 [2, 4, 5, 6, 1, 3]。

再处理下一个元素 1。我们将 1 与已排序序列中的元素依次比较，发现它应该插入到第一个位置，得到序列 [1, 2, 4, 5, 6, 3]。

最后，我们处理最后一个元素 3。我们将 3 与已排序序列中的元素依次比较，发现它应该插入到第三个位置，得到最终排序结果 [1, 2, 3, 4, 5, 6]。

通过这个例子，我们可以看到插入排序的过程就是通过不断地将元素插入到已排序序列中的适当位置，逐步形成有序序列的过程。

具体实现步骤如下：

1. 将第一个元素当作已排序部分，将剩余的元素看作未排序部分。
2. 从未排序部分选择一个元素，插入到已排序部分的合适位置。这个位置是在已排序部分中找到一个比待插入元素大的元素之前的位置。
3. 重复步骤2，直到未排序部分为空。

以下是一个示例的插入排序过程：

待排序数组：[7, 3, 5, 9, 1, 4]

第一次插入排序：已排序部分：[7]，未排序部分：[3, 5, 9, 1, 4] 从未排序部分选择元素3，插入到已排序部分的合适位置，得到已排序部分：[3, 7]，未排序部分：[5, 9, 1, 4]

第二次插入排序：已排序部分：[3, 7]，未排序部分：[5, 9, 1, 4] 从未排序部分选择元素5，插入到已排序部分的合适位置，得到已排序部分：[3, 5, 7]，未排序部分：[9, 1, 4]

第三次插入排序：已排序部分：[3, 5, 7]，未排序部分：[9, 1, 4] 从未排序部分选择元素9，插入到已排序部分的合适位置，得到已排序部分：[3, 5, 7, 9]，未排序部分：[1, 4]

第四次插入排序：已排序部分：[3, 5, 7, 9]，未排序部分：[1, 4] 从未排序部分选择元素1，插入到已排序部分的合适位置，得到已排序部分：[1, 3, 5, 7, 9]，未排序部分：[4]

第五次插入排序：已排序部分：[1, 3, 5, 7, 9]，未排序部分：[4] 从未排序部分选择元素4，插入到已排序部分的合适位置，得到已排序部分：[1, 3, 4, 5, 7, 9]，未排序部分：[]

最终排序结果：[1, 3, 4, 5, 7, 9]

插入排序的时间复杂度为O(n^2)，其中n为待排序数组的长度。对于有序数组，插入排序的时间复杂度为O(n)，是一种稳定的排序算法。

减少队列和构建新的队列，新的队列插入算法可以优化。

以下是插入排序的一种常见模板：

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

这个模板中，使用一个 for 循环遍历未排序序列的每个元素，将当前元素插入到已排序序列的适当位置。

你可以调用 insertion_sort 函数并传入一个待排序的数组来测试它的功能。例如：

python复制插入

arr = [4, 2, 5, 1, 3]
sorted_arr = insertion_sort(arr)
print(sorted_arr)  # 输出 [1, 2, 3, 4, 5]

复制插入

这个插入排序算法的时间复杂度是 O(n^2)，其中 n 是待排序数组的长度。

内部使用一个 while 循环来找到当前元素应该插入的位置。该循环将已排序序列中比当前元素大的元素往后移动一个位置，直到找到不大于当前元素的位置。最后将当前元素插入到正确位置。

时间复杂度为 O(n^2)，空间复杂度为 O(1)。