Python排序
一、冒泡排序
冒泡排序算法的运作如下：
- 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
def bubbleSort(lyst): n = len(lyst) while n > 1: flag = False # flag作为一个标志位，如果在通过某轮循环时没有发生元素交换，这时说明列表已经排序好了，可以直接退出循环 i = 1 while i < n: if lyst[i] < lyst[i - 1]: # 如果一个元素比它前面的元素小，则交换两个元素 lyst[i], lyst[i - 1] = lyst[i - 1], lyst[i] flag = True i += 1 # 元素index加一，继续往后 if not flag: return lyst n -= 1 # 完成一轮比较，减一 return lyst if __name__ == "__main__": li = [5, 6, 1, 3, 89, 23, 56, 15, 95] result = bubbleSort(li) print(result)
二、选择排序
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
def select_sort(lyst): n = len(lyst) for j in range(0, n - 1): # 需要进行n-1次选择操作，j：0~n-2 min_index = j # 记录最小位置 # 从i+1位置到末尾选择出最小数据的下标，并进行数值交换 for i in range(j + 1, n): # i：j+1~n-1 if lyst[min_index] > lyst[i]: min_index = i # 如果选择出的数据不在正确位置，进行交换,如果选出的数据刚好在正确的位置就不进行交换了 if min_index != i: lyst[j], lyst[min_index] = lyst[min_index], lyst[j] if __name__ == "__main__": li = [1, 6, 2, 3, 89, 23, 1, 56, 15, 95] select_sort(li) print(li)
三、插入排序
通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
def Insert_Sort(lyst): n = len(lyst) # 从右边的无序序列中取出多少个元素执行这样的过程 for j in range(1, n): # j = [1, 2, 3,..., n-1] # i 代表内层循环起始值 i = j # 执行从右边的无序序列中取出第一个元素，即i位置的元素，然后将其插入到前面的正确位置 while i > 0: if lyst[i] < lyst[i - 1]: lyst[i], lyst[i - 1] = lyst[i - 1], lyst[i] i -= 1 else: break if __name__ == "__main__": li = [5, 6, 1, 3, 89, 23, 56, 15, 95] Insert_Sort(li) print(li)
四、希尔排序
希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
希尔排序过程
希尔排序的基本思想是：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。
例如，假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我们以步长为5开始进行排序，我们可以通过将这列表放在有5列的表中来更好地描述算法，这样他们就应该看起来是这样(竖着的元素是步长组成)：
13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10
然后我们对每列进行排序：
10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45
将上述四行数字，依序接在一起时我们得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]。这时10已经移至正确位置了，然后再以3为步长进行排序：
10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45
排序之后变为：
10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94
最后以1步长进行排序（此时就是简单的插入排序了）
def Shell_Sort(lyst): n = len(lyst) # 初始步长 gap = n // 2 # gap变化到0之前，插入算法执行的次数 while gap >= 1: # 或者 gap>0 # 插入算法，与普通的插入算法区别就是gap步长 for j in range(gap, n): # j = [gap, gap+1, gap+2,...,n-1] i = j while i > 0: if lyst[i] < lyst[i - gap]: lyst[i], lyst[i - gap] = lyst[i - gap], lyst[i] i -= gap else: break # 缩短gap步长 gap //= 2 if __name__ == "__main__": li = [54, 26, 93, 17, 77, 31, 44, 55, 20] Shell_Sort(li) print(li)
五、快速排序
快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
步骤为：
- 从数列中挑出一个元素，称为"基准"（pivot），
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
# This Python file uses the following encoding: utf-8 def Quick_Sort(lyst, start, end): if start >= end: # 递归的退出条件 return pivot = lyst[start] # 设定起始的基准元素 low = start # low为序列左边在开始位置的由左向右移动的游标 high = end # high为序列右边末尾位置的由右向左移动的游标 while low < high: # 如果low与high未重合，high(右边)指向的元素大于等于基准元素，则high向左移动 while low < high and lyst[high] >= pivot: high -= 1 lyst[low] = lyst[high] # 走到此位置时high指向一个比基准元素小的元素,将high指向的元素放到low的位置上,此时high指向的位置空着,接下来移动low找到符合条件的元素放在此处 # 如果low与high未重合，low指向的元素比基准元素小，则low向右移动 while low < high and lyst[low] < pivot: low += 1 lyst[high] = lyst[low] # 此时low指向一个比基准元素大的元素,将low指向的元素放到high空着的位置上,此时low指向的位置空着,之后进行下一次循环,将high找到符合条件的元素填到此处 # 退出循环后，low与high重合，此时所指位置为基准元素的正确位置,左边的元素都比基准元素小,右边的元素都比基准元素大 lyst[low] = pivot # 将基准元素放到该位置, # 对基准元素左边的子序列进行快速排序 Quick_Sort(lyst, start, low - 1) # start :0 low -1 原基准元素靠左边一位 # 对基准元素右边的子序列进行快速排序 Quick_Sort(lyst, low + 1, end) # low+1 : 原基准元素靠右一位 end: 最后 if __name__ == '__main__': li = [54, 26, 93, 17, 77, 31, 44, 55, 20] Quick_Sort(li, 0, len(li) - 1) print(li)
六、归并排序
归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。
将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。
def Merge_Sort(lyst): n = len(lyst) if n <= 1: return lyst # 二分分解 mid = n // 2 # left采用归并排序后形成的有序的新列表 left_li = Merge_Sort(lyst[:mid]) # right 采用归并排序后形成的有序的新列表 right_li = Merge_Sort(lyst[mid:]) """合并操作，将两个有序数组left_li[]和right_li[]合并成一个大的有序数组""" left_pointer, right_pointer = 0, 0 result = [] while left_pointer < len(left_li) and right_pointer < len(right_li): if left_li[left_pointer] < right_li[right_pointer]: result.append(left_li[left_pointer]) left_pointer += 1 else: result.append(right_li[right_pointer]) right_pointer += 1 result += left_li[left_pointer:] result += right_li[right_pointer:] return result if __name__ == '__main__': li = [54, 26, 93, 17, 77, 31, 44, 55, 20] sort_li = Merge_Sort(li) print(sort_li)
浙公网安备 33010602011771号