排序数据可能是你在程序中需要做的最常见的任务。作为许多不同在线应用程序的用户，你每天都在对数据进行排序。每一个购物网站都允许你对数据进行排序。例如，你可以按最低价格、最高价格、客户评论数量、平均评论分数等进行排序。不管是亚马逊、Target、Barnes n Noble，还是乐高商店，都无所谓。这一切都很容易做到，作为用户，我们所要做的就是点击一个链接，我们的数据就被排序了。排序问题已经解决了，所有现代编程语言都已经内置了排序逻辑，而且它们非常高效，所以你不需要实现你自己的排序算法。了解一些常见的排序技术的理论和应用确实有帮助，这就是我们现在要研究的。
泡沫排序
泡沫排序是要学习的第一个排序算法。你不可能在野外使用它，因为它不是很有效。然而，它很容易理解，而且是要学习的第一个排序例程。冒泡排序的开始是将前两个元素相互比较，看哪个更大。如果第一个元素比第二个元素大，那么这两个元素就会被调换。然后冒泡排序继续前进，对下两个元素做同样的操作。这个过程一直持续到数组中的所有项目都被检查过，而且最大的值已经全部移到了数组的右边（顶部）。然后，该算法重复整个过程，对所有元素进行操作，除了最后一个项目之前的元素，然后是之前的元素，以此类推，直到数组被完全排序。
这个可视化的过程就是下面代码例子的第一遍。
- 更容易理解和实现
- 性能不是很好。O(n2)
- 其他排序算法的性能更高
- 是一个很好的第一个学习的排序算法
泡沫排序的Python代码
def bubbleSort(data_to_sort):
for i in range(len(data_to_sort) - 1, 0, -1):
for j in range(i):
if data_to_sort[j] > data_to_sort[j + 1]:
temp = data_to_sort[j]
data_to_sort[j] = data_to_sort[j + 1]
data_to_sort[j + 1] = temp
print(f'Iteration: {abs(i - len(data_to_sort))}', data_to_sort)
list_to_sort = [90, 50, 10, 20, 70, 60, 40, 30, 80]
print('Original List: ', list_to_sort)
bubbleSort(list_to_sort)
print('Sorted List: ', list_to_sort)
Original List: [90, 50, 10, 20, 70, 60, 40, 30, 80]
Iteration: 1 [50, 10, 20, 70, 60, 40, 30, 80, 90]
Iteration: 2 [10, 20, 50, 60, 40, 30, 70, 80, 90]
Iteration: 3 [10, 20, 50, 40, 30, 60, 70, 80, 90]
Iteration: 4 [10, 20, 40, 30, 50, 60, 70, 80, 90]
Iteration: 5 [10, 20, 30, 40, 50, 60, 70, 80, 90]
Iteration: 6 [10, 20, 30, 40, 50, 60, 70, 80, 90]
Iteration: 7 [10, 20, 30, 40, 50, 60, 70, 80, 90]
Iteration: 8 [10, 20, 30, 40, 50, 60, 70, 80, 90]
Sorted List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
合并排序
合并排序是一种分而治之的算法，它把一个数组分成小块来操作。合并排序比冒泡排序有更好的性能。它的工作原理是连续地将一个数组分解，直到只剩下每个元素的单独数组。在这一点上，该算法开始将这些数组相互合并，直到原数组被重建为完全排序。
- 分割和征服
- 将数组分解成各个部分
- 使用递归法对数据进行操作
- 将这些碎片以排序的形式合并到阵列中去
- 在大量的数据上有很好的性能
合并排序Python代码
def mergesort(data_to_sort):
if len(data_to_sort) > 1:
mid = len(data_to_sort) // 2
leftarray = data_to_sort[:mid]
rightarray = data_to_sort[mid:]
mergesort(leftarray)
mergesort(rightarray)
i, j, k = 0, 0, 0
while i < len(leftarray) and j < len(rightarray):
if leftarray[i] < rightarray[j]:
data_to_sort[k] = leftarray[i]
i += 1
else:
data_to_sort[k] = rightarray[j]
j += 1
k += 1
while i < len(leftarray):
data_to_sort[k] = leftarray[i]
i += 1
k += 1
while j < len(rightarray):
data_to_sort[k] = rightarray[j]
j += 1
k += 1
list_to_sort = [90, 50, 10, 20, 70, 60, 40, 30, 80]
print('Original List: ', list_to_sort)
mergesort(list_to_sort)
print('Sorted List: ', list_to_sort)
Original List: [90, 50, 10, 20, 70, 60, 40, 30, 80]
Sorted List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
快速排序
Quicksort也是一种分而治之的算法，它使用递归来完成其工作，通常比Merge Sort有更好的性能。Quicksort在现有数组中就地完成数据的排序。Quicksort的主要特点是选择一个支点。枢轴点用于开始对数组进行分区。分区过程的目的是移动位于支点值错误一侧的项目，并找出分割数组的点。在快速排序中，有一个下位索引和一个上位索引。开始时，只要下层索引小于上层索引，它就会递增，直到找到一个大于枢轴值的数值。然后，上层索引被递减，直到找到一个小于枢轴值的值，只要上层索引比下层索引大。当这两个索引相互交叉时，数组被分割。然后，枢轴值与上层索引互换，因此左边包含低于枢轴的值，右边包含高于枢轴的值。这个过程一直持续到数组不能再被分割为止。所有的排序逻辑都在快速排序的分割步骤中完成，数据被排序到位。
快速排序的Python代码
def quickSort(data_to_sort, first, last):
if first < last:
pivotindex = partition(data_to_sort, first, last)
quickSort(data_to_sort, first, pivotindex - 1)
quickSort(data_to_sort, pivotindex + 1, last)
def partition(values, first, last):
pivotvalue = values[first]
lower = first + 1
upper = last
done = False
while not done:
while lower <= upper and values[lower] <= pivotvalue:
lower += 1
while values[upper] >= pivotvalue and upper >= lower:
upper -= 1
if upper < lower:
done = True
else:
temp = values[lower]
values[lower] = values[upper]
values[upper] = temp
temp = values[first]
values[first] = values[upper]
values[upper] = temp
return upper
list_to_sort = [90, 50, 10, 20, 70, 60, 40, 30, 80]
print('Original List: ', list_to_sort)
quickSort(list_to_sort, 0, len(list_to_sort) - 1)
print('Sorted List: ', list_to_sort)
Original List: [90, 50, 10, 20, 70, 60, 40, 30, 80]
Sorted List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Python中的泡沫排序、合并排序和快速排序 摘要
有许多算法可以对数据进行排序。我们看了一下在Python中实现的三种比较常见的算法。它们是泡沫排序、合并排序和快速排序。每一种都有与之相关的算法复杂性，以及不同程度的性能和易用性。
