用Python写一个归并算法

### 回答1：

答：我可以给你一个简单的归并算法的Python代码：

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

### 回答2：
归并排序是一种经典的排序算法，它的基本思想是将待排序的序列递归地划分成较小的子序列，然后对这些子序列进行排序，最后再将已排序的子序列进行合并，得到最终的有序序列。

下面是用Python实现归并算法的代码：

def mergeSort(arr):
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left = mergeSort(arr[:mid])
    right = mergeSort(arr[mid:])

    return merge(left, right)


def merge(left, right):
    result = []
    i = 0
    j = 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


arr = [5, 3, 8, 6, 2, 7, 1, 4]
sorted_arr = mergeSort(arr)
print(sorted_arr)

以上代码中，`mergeSort` 函数用于实现归并排序，它将输入的列表递归地划分成较小的子序列，并将左右子序列分别排序后再合并。`merge`函数用于将两个已经排序的子序列合并为一个有序序列。

在实际调用时，我们可以将待排序的列表作为输入传给`mergeSort`函数，并将返回的有序序列赋给`sorted_arr`变量。最后将`sorted_arr`打印出来，即可得到排序后的结果。

以上就是用Python实现归并算法的代码。

### 回答3：
归并排序是一种经典的排序算法。它的基本思想是将一个待排序的序列不断递归地分成两个子序列，直到每个子序列只包含一个元素。然后逐步将这些子序列合并成一个有序的序列，最终得到排序好的序列。

下面是用Python实现归并算法的例子：

def merge_sort(arr):
    # 递归结束条件：当数组长度为1时，返回数组本身
    if len(arr) <= 1:
        return arr
    
    # 将数组分成两个子数组
    mid = len(arr) // 2
    left_arr = arr[:mid]
    right_arr = arr[mid:]
    
    # 分别对左右两个子数组进行递归排序
    left_arr = merge_sort(left_arr)
    right_arr = merge_sort(right_arr)
    
    # 合并两个有序子数组
    return merge(left_arr, right_arr)

def merge(left_arr, right_arr):
    merged_arr = []
    i = j = 0
    
    # 比较两个子数组中的元素，按照从小到大的顺序合并到merged_arr中
    while i < len(left_arr) and j < len(right_arr):
        if left_arr[i] < right_arr[j]:
            merged_arr.append(left_arr[i])
            i += 1
        else:
            merged_arr.append(right_arr[j])
            j += 1
    
    # 将剩余未合并的元素添加到merged_arr中
    merged_arr.extend(left_arr[i:])
    merged_arr.extend(right_arr[j:])
    
    return merged_arr

# 示例：
arr = [7, 2, 1, 6, 3, 5, 4]
sorted_arr = merge_sort(arr)
print(sorted_arr)

以上代码使用递归的思想实现了归并排序算法。它首先将待排序的序列不断递归地分成两个子序列，然后再将这些子序列逐步合并成一个有序的序列，最终得到排序好的序列。运行以上代码，输出排序后的序列为：[1, 2, 3, 4, 5, 6, 7]。