📅 最后修改于: 2020-10-29 01:29:01 🧑 作者: Mango
合并排序类似于快速排序算法，它适用于分而治之的概念。它是最流行，最有效的排序算法之一。这是划分和征服算法类别的最佳示例。
它将给定的列表分为两半，将自己称为两半，然后合并两个排序的两半。我们定义用于合并两个半部分的merge()函数。
子列表一次又一次地分成两半，直到每个子列表只有一个元素为止。然后，我们将一对一个元素列表组合成两个元素列表，并在此过程中对它们进行排序。将排序后的两个元素对合并到四个元素列表中，依此类推，直到获得排序后的列表。
让我们看下面的Merge排序图。
我们将给定的列表分为两半。列表不能分成相等的部分，这一点都没有关系。
可以使用两种方式实现合并排序-自上而下的方法和自下而上的方法。在上面的示例中，我们使用了自上而下的方法，这是最常用的合并排序。
自下而上的方法提供了更多优化，我们将在后面定义。
该算法的主要部分是我们如何组合两个排序的子列表。让我们合并两个排序的合并列表。
首先，我们观察两个列表的第一个元素。我们发现B的第一个元素较小，因此我们将其添加到排序列表中，然后在B列表中继续前进。
现在，我们看一下元素2和3的下一个对。2个元素较小，因此我们将其添加到已排序的列表中并前进到该列表。
继续此过程，最后得到{1、2、3、4、7、8、11}的排序列表。可能有两种特殊情况。
我们应该记住，我们可以按任何顺序对元素进行排序。我们将给定列表按升序排序，但是我们可以轻松地按降序排序。
合并排序算法是通过使用自顶向下方法实现的。看起来有些困难，因此我们将详细说明每个步骤。在这里，我们将在两种类型的集合上实现此算法-整数元素的列表(通常用于引入排序)和自定义对象(更实际，更实际的场景)。
算法的主要概念是将(子)列表分为两半，然后对它们进行递归排序。我们继续该过程，直到最终得到只有一个元素的列表。让我们了解以下除法函数-
def merge_sort(array, left_index, right_index):
if left_index >= right_index:
return middle = (left_index + right_index)//2
merge_sort(array, left_index, middle)
merge_sort(array, middle + 1, right_index)
merge(array, left_index, right_index, middle)
我们的主要重点是在排序之前将列表分为多个子部分。我们需要获取整数值，因此我们对索引使用//运算符。
让我们通过以下步骤了解上述过程。
让我们在Python程序中实现合并排序。
# funtion to divide the lists in the two sublists
def merge_sort(list1, left_index, right_index):
if left_index >= right_index:
return
middle = (left_index + right_index)//2
merge_sort(list1, left_index, middle)
merge_sort(list1, middle + 1, right_index)
merge(list1, left_index, right_index, middle)
# Defining a function for merge the list
def merge(list1, left_index, right_index, middle):
# Creating subparts of a lists
left_sublist = list1[left_index:middle + 1]
right_sublist = list1[middle+1:right_index+1]
# Initial values for variables that we use to keep
# track of where we are in each list1
left_sublist_index = 0
right_sublist_index = 0
sorted_index = left_index
# traverse both copies until we get run out one element
while left_sublist_index < len(left_sublist) and right_sublist_index < len(right_sublist):
# If our left_sublist has the smaller element, put it in the sorted
# part and then move forward in left_sublist (by increasing the pointer)
if left_sublist[left_sublist_index] <= right_sublist[right_sublist_index]:
list1[sorted_index] = left_sublist[left_sublist_index]
left_sublist_index = left_sublist_index + 1
# Otherwise add it into the right sublist
else:
list1[sorted_index] = right_sublist[right_sublist_index]
right_sublist_index = right_sublist_index + 1
# move forward in the sorted part
sorted_index = sorted_index + 1
# we will go through the remaining elements and add them
while left_sublist_index < len(left_sublist):
list1[sorted_index] = left_sublist[left_sublist_index]
left_sublist_index = left_sublist_index + 1
sorted_index = sorted_index + 1
while right_sublist_index < len(right_sublist):
list1[sorted_index] = right_sublist[right_sublist_index]
right_sublist_index = right_sublist_index + 1
sorted_index = sorted_index + 1
list1 = [44, 65, 2, 3, 58, 14, 57, 23, 10, 1, 7, 74, 48]
merge_sort(list1, 0, len(list1) -1)
print(list1)
输出：
[1, 2, 3, 7, 10, 14, 23, 44, 48, 57, 58, 65, 74]
我们还可以使用Python类对自定义对象进行排序。该算法与上面的算法几乎相似，但是我们需要使其更具通用性并通过比较函数。
我们将创建一个自定义类Car，并向其中添加一些字段。我们对以下算法进行了一些改动，以使其更具通用性。我们可以通过使用lambda函数来实现。
让我们了解以下示例。
class Car:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
def __str__(self):
return str.format("Make: {}, Model: {}, Year: {}", self.make, self.model, self.year)
def merge(list1, l, r, m, comp_fun):
left_copy = list1[l:m + 1]
r_sublist = list1[m+1:r+1]
left_copy_index = 0
r_sublist_index = 0
sorted_index = l
while left_copy_index < len(left_copy) and r_sublist_index < len(r_sublist):
# We use the comp_fun instead of a simple comparison operator
if comp_fun(left_copy[left_copy_index], r_sublist[r_sublist_index]):
list1[sorted_index] = left_copy[left_copy_index]
left_copy_index = left_copy_index + 1
else:
list1[sorted_index] = r_sublist[r_sublist_index]
r_sublist_index = r_sublist_index + 1
sorted_index = sorted_index + 1
while left_copy_index < len(left_copy):
list1[sorted_index] = left_copy[left_copy_index]
left_copy_index = left_copy_index + 1
sorted_index = sorted_index + 1
while r_sublist_index < len(r_sublist):
list1[sorted_index] = r_sublist[r_sublist_index]
r_sublist_index = r_sublist_index + 1
sorted_index = sorted_index + 1
def merge_sort(list1, l, r, comp_fun):
if l >= r:
return
m = (l + r)//2
merge_sort(list1, l, m, comp_fun)
merge_sort(list1, m + 1, r, comp_fun)
merge(list1, l, r, m, comp_fun)
car1 = Car("Renault", "33 Duster", 2001)
car2 = Car("Maruti", "Maruti Suzuki Dzire", 2015)
car3 = Car("Tata motor", "Jaguar", 2004)
car4 = Car("Cadillac", "Seville Sedan", 1995)
list1 = [car1, car2, car3, car4]
merge_sort(list1, 0, len(list1) -1, lambda carA, carB: carA.year < carB.year)
print("Cars sorted by year:")
for car in list1:
print(car)
print()
merge_sort(list1, 0, len(list1) -1, lambda carA, carB: carA.make < carB.make)
print("Cars sorted by make:")
for car in list1:
print(car)
输出：
Cars sorted by year:
Make: Cadillac, Model: Seville Sedan, Year: 1995
Make: Renault, Model: 33 Duster, Year: 2001
Make: Tata motor, Model: Jaguar, Year: 2004
Make: Maruti, Model: Maruti Suzuki Dzire, Year: 2015
Cars sorted by make:
Make: Cadillac, Model: Seville Sedan, Year: 1995
Make: Maruti, Model: Maruti Suzuki Dzire, Year: 2015
Make: Renualt, Model: 33 Duster, Year: 2001
Make: Tata motor, Model: Jaguar, Year: 2004
我们可以提高合并排序算法的性能。首先，让我们了解自顶向下和自底向上合并排序之间的区别。自下而上的方法将相邻列表的元素进行迭代排序，而自上而下的方法将列表分为两半。
给定的列表为[10，4，2，12，1，3]，而不是将其分解为[10]，[4]，[2]，[12]，[1]，[3]-进入可能已经排序的子列表：[10，4]，[2]，[1，12]，[3]，现在可以对其进行排序了。
对于较小的子列表，合并排序在时间和空间上都是效率低下的算法。因此，对于较小的子列表，插入排序比合并排序更为有效。
合并排序是一种流行且高效的算法。对于大型列表，这是一种更有效的算法。它不取决于导致运行时不好的任何不幸决定。
合并排序有一个主要缺点。在合并列表之前，它会使用额外的内存来存储列表的临时副本。但是，合并排序在软件中被广泛使用。它的性能快速，并产生优异的效果。
我们已经简要讨论了合并排序概念，并通过用于比较的lambda函数在简单整数列表和自定义对象上实现了合并排序概念。