Python数据结构之排序

冒泡排序

• 它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来
• 算法运作：
  1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
  3. 针对所有的元素重复以上的步骤，除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

def bubble_sort(li):
	"""冒泡排序"""
	for j in range(len(li)-1, 0, -1):  # 每次遍历需要比较的次数，逐渐减小
		for i in range(0, j):
			# 比较相邻两数，大的放右边
			if li[i] > li[i+1]:
				li[i], li[i+1] = li[i+1], li[i]

• 时间复杂度：
  1. 最优时间复杂度：O(n) （表示遍历一次发现没有任何可以交换的元素，排序结束。）
  2. 最坏时间复杂度：O(n^2)
• 稳定性：稳定

选择排序

• 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

def select_sort(li):
	n = len(li)
	for j in range(n-1):  # 进行n-1次排序
		min_index = j  # 最小序列
		for i in range(j+1, n):
			if li[i] < li[min_index ]:
				min_index = i  # 选出最小序列
		if min_index != j:
			li[j], li[min_index ] = li[min_index ], li[j]

• 时间复杂度：
  1. 最优时间复杂度：O(n^2)
  2. 最坏时间复杂度：O(n^2)
• 稳定性：不稳定

插入排序

• 通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

def insert_sort(li):
	"""插入排序"""
	# 从第二个元素下标开始比较
	for i in range(1, len(li)):
		for j in range(i, 0, -1):  # 假设一个有序数列
			# 从第j 个元素开始向前比较，遇到小的则交换。
			if li[j] < li[j - 1]:
				li[j], li[j - 1] = li[j - 1], li[j]
			else:
				brea

• 时间复杂度：
  1. 最优时间复杂度：O(n) （升序排列，序列已经处于升序状态）
  2. 最坏时间复杂度：O(n^2)
• 稳定性：稳定

希尔排序

• 也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。
• 将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。

def shell_sort(li):
	n = len(li)
	# 确定初始步长：
	gap = n // 2
	while gap > 0:
		# 按照步长，进行插入排序
		for i in range(gap, n):
			j = i
			while j >= gap and li[j] < li[j-gap]:
				li[j], li[j-gap] = li[j-gap], li[j]
				j -= gap
		gap //= 2

• 时间复杂度：
  1. 最优时间复杂度：根据步长序列的不同而不同
  2. 最坏时间复杂度：O(n^2)
• 稳定性：不稳定

快速排序

• 又称划分交换排序（partition-exchange sort），通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

• 步骤：

  • 从数列中挑出一个元素，称为"基准"（pivot），
  • 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
  • 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

def quick_sort(li, start, end):
	"""
    快速排序
    :param li: 需要排序的列表
    :param start: 起始下标
    :param end: 结束下标
    :return:
    """
    # 退出递归条件
    if start >= end:
    	return
    # 取开始数为基准数
    mid = li[start]
    # 序列从左向右游标
    life = start
    # 序列从右向左游标
    right = end
    while left < right:
    	# 先从右游标开始移动
    	while left < right and li[right] > mid:
    		right -= 1
    	# 右游标的数交给坐游标
    	li[life] = li[right]
    	# 从左往右移动
    	while left < right and li[left] <= mid:
    		left += 1
    	li[right] = li[left]
    # 退出循环后，low与high重合，此时所指位置为基准元素的正确位置
    # 将基准元素放到该位置
    li[left] = mid
	# 递归
    quick_sort(li, start, left - 1)
    quick_sort(li, left + 1, end)

归并排序

• 先递归分解数组，再合并数组。

def merge_sort(li):
    """归并排序"""
    n = len(li)

    # 递归的退出条件
    if n == 1:
        return li

    mid = n // 2
    left_li = li[:mid]
    right_li = li[mid:]

    # 对左半部分排序，按照归并思想
    left_sorted_li = merge_sort(left_li)

    # 对右半部分进行排序
    right_sorted_li = merge_sort(right_li)

    # 设置2个游标
    left, right = 0, 0

    left_n = len(left_sorted_li)
    right_n = len(right_sorted_li)

    # 进行合并
    merged_li = []

    while left < left_n or right < right_n:
        if left_sorted_li[left] <= right_sorted_li[right]:
            merged_li.append(left_sorted_li[left])
            left += 1
        else:
            merged_li.append(right_sorted_li[right])
            right += 1

    # 退出循环时表示有一个列表的所有元素都已经添加到新的列表中
    # 处理剩下的列表
    merged_li.extend(left_sorted_li[left:])
    merged_li.extend(right_sorted_li[right:])

    return merged_li

• 时间复杂度：
  1. 最优时间复杂度：O(nlogn)
  2. 最坏时间复杂度：O(nlogn)
• 稳定性：稳定