对仅交换两个元素的几乎排序的数组进行排序

在实际应用中，我们有时会遇到仅有两个元素的位置发生了交换导致原有的数组成为了几乎排序的数组，这时候我们需要编写一个快速又高效的算法对其进行排序。

思路

考虑到只有两个元素被交换位置造成的影响，我们可以使用一次遍历，找出不符合升序规律的两个元素，并将其交换位置。

以升序为例，先设首位为错误位置，继续遍历，找到后面不符合升序规律的最大位置，然后再从前面遍历，找到不符合升序规律的最小位置，最后将它们交换一下位置即可。

具体实现见代码。

代码实现

def sort_almost_sorted_array(arr: list):
    first_failure = None  # 第一个不符合升序规律的位置，初始化为None
    for i in range(len(arr) - 1):
        if arr[i] > arr[i + 1]:
            first_failure = i
            break
    if first_failure is None:
        return arr  # 若整个数组都满足升序规律，则直接返回原数组
    else:
        second_failure = None  # 第二个不符合升序规律的位置，初始化为None
        for j in range(first_failure + 1, len(arr) - 1):
            if arr[j] > arr[j + 1]:
                second_failure = j + 1
        if second_failure is None:
            second_failure = len(arr) - 1
        for k in range(first_failure + 1):
            if arr[k] > arr[second_failure]:
                arr[k], arr[second_failure] = arr[second_failure], arr[k]
                break
        for l in range(len(arr) - 1, second_failure, -1):
            if arr[l] < arr[first_failure]:
                arr[l], arr[first_failure] = arr[first_failure], arr[l]
                break
        return arr  # 返回已排序数组

测试样例

为了验证代码实现的正确性，我们编写了如下测试函数：

def test_sort_almost_sorted_array():
    assert sort_almost_sorted_array([1, 4, 3, 7, 10, 9, 11]) == [1, 3, 4, 7, 9, 10, 11]
    assert sort_almost_sorted_array([2, 3, 4, 1, 8, 6, 7, 5, 9]) == [1, 2, 3, 4, 5, 6, 7, 8, 9]
    assert sort_almost_sorted_array([1, 2, 5, 4, 3, 6]) == [1, 2, 3, 4, 5, 6]
    assert sort_almost_sorted_array([1, 3, 2]) == [1, 2, 3]
    assert sort_almost_sorted_array([1, 2, 3]) == [1, 2, 3]
    
test_sort_almost_sorted_array()

所有测试通过，实现符合预期。

结言

通过以上介绍，我们可以编写出一个快速又高效的算法对仅交换两个元素的几乎排序数组进行排序。由于代码实现简单，时间复杂度仅为$O(n)$，因此我们可以在实际应用中广泛使用。