对有序和无序的数组排序

对具有前 N 个元素已排序且最后 M 个元素未排序的数组进行排序是一种特殊情况，可以使用一些特殊的算法或者修改常见的排序算法来解决。

冒泡排序

由于前 N 个元素已经有序，我们可以使用冒泡排序的变种，仅对后 M 个元素进行冒泡排序。

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        # 最后 i 个元素已经有序
        for j in range(1, n-i):
            if arr[j-1] > arr[j]:
                arr[j-1], arr[j] = arr[j], arr[j-1]
    return arr

def sort_array(arr, n, m):
    # 对后 M 个元素进行冒泡排序
    sorted_arr = bubble_sort(arr[n:])
    # 将有序的后 M 个元素和前 N 个元素合并
    sorted_arr.extend(arr[:n])
    return sorted_arr

插入排序

由于前 N 个元素已经有序，我们可以使用插入排序的变种，仅对后 M 个元素进行插入排序。

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

def sort_array(arr, n, m):
    # 对后 M 个元素进行插入排序
    insertion_sort(arr[n:])
    # 将有序的后 M 个元素和前 N 个元素合并
    sorted_arr = arr[:n] + arr[n:]
    return sorted_arr

归并排序

归并排序是一种效率高且稳定的排序算法，可以适用于对任何类型的数组进行排序。

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

def sort_array(arr, n, m):
    # 将前 N 个元素和后 M 个元素分别进行归并排序
    merge_sort(arr[:n])
    merge_sort(arr[n:])
    i = j = k = 0
    sorted_arr = []
    while i < n and j < m:
        if arr[i] < arr[n+j]:
            sorted_arr.append(arr[i])
            i += 1
        else:
            sorted_arr.append(arr[n+j])
            j += 1
        k += 1
    while i < n:
        sorted_arr.append(arr[i])
        i += 1
        k += 1
    while j < m:
        sorted_arr.append(arr[n+j])
        j += 1
        k += 1
    return sorted_arr

注意：上述代码仅是为了演示如何处理具有已排序与未排序元素的数组，实际使用时需要根据具体的需求作相应的修改。