Python数据结构第五天

冒泡排序（稳定）：
重复的遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就交换过来，直到没有再需要交换的数据
时间复杂度：平均情况O(n²)，最好情况O(n)，最坏情况O(n²)，辅助空间O(1)

def bubble_sort(alist):
	"""冒泡排序"""
	n = len(alist)
	for j in range(0, n-1):
		count = 0
		for i in range(0, n-1-j):
			# 游标从头走到尾
			if alist[i] > alist[i+1]:
				alilst[i], alist[i+1] = alist[i+1], alist[i]
				count += 1
		if 0 == count:
			return

选择排序（不稳定）：
首先在未排序的序列中找到最小（大）元素，存放到排序序列的起始位置，再从剩余的元素中继续找最小（大）的元素，放到已排序序列的末尾，直到所有元素排列完毕
时间复杂度：平均情况O(n²)，最好情况O(n²)，最坏情况O(n²)，辅助空间O(1)

def select_sort(alist):
	"""选择排序"""
	n = len(alist)
	for j in range(n-1): # j：0 ~ n-2
		min_index = j # 假设0位置的元素最小
		for i in range(j+1, n):
			if alist[min_index] > alist[i]:
				min_index = i
		alist[j], alist[min_index] = a;sit[min_index], alist[j]

插入排序（稳定）：
原理是构筑有序序列，对于未排序的数据，在意排序的序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描的过程中，需要反复把已排序元素逐步往后挪位，为新元素提供插入空间
时间复杂度：平均情况O(n²)，最好情况O(n)，最坏情况O(n²)，辅助空间O(1)

def insert_sort():
	"""插入排序"""
	n = len(alist)
	# 从右边的无需序列中取出多少个元素执行这样的过程
	for j in range(1, n):
		# i代表内层循环起始值
		# 执行从右边的无序序列取出第一个元素，即i位置的元素，然后将其插入到前面的正确位置中
		i = j
		while i > 0:
			if alist[i] < alist[i-1]:
				alist[i], alist[i-1] = alist[i-1], alist[i]
				i -= 1
			else:
				break

希尔排序（不稳定）：
是插入排序的一种，也称缩小增量排序，是直接插入排序算法的一种更高效的改进版。希尔排序是把记录按下标的一等增量分组，对每组使用直接插入排序算法，随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分为一组，算法便终止
希尔排序的效率不一定比插入排序更高
时间复杂度：平均情况O(nlogn)~O(n²)，最好情况O(n^1.3)，最坏情况O(n²)，辅助空间O(1)

def shell_sort(alist):
	"""希尔排序"""
	n = len(alist)
	gap = n//2 # 取整	
	i = 1
	# gap变化到0之前，插入算法执行的次数
	while gap >= 1:
		# 插入算法，与空的插入算法的区别就是gap步长
		for j in range(gap, n):
			i = j
			while i > 0:
				if alist[i] < alist[i-gap]:
					alist[i], alist[i-gap] = alist[i-gap], alist[i]
					i -= gap
				else:
					break
			# 缩短gap步长
			gap //= 2

快速排序（不稳定）：
两个指针，分别从头和尾开始对比，当两个指针重合时，就是正在寻在的数在列表中的位置
时间复杂度：平均情况O(nlogn)，最好情况O(nlogn)，最坏情况O(n²)，辅助空间O(nlogn)~O(n)

def quick_sort(alist, first, last):
	"""快速排序"""
	if first >= last:
		return
	mid_value = alist[0]
	low = 0
	high = n - 1
	
	while low < high:
		# high左移
		while low < high and alist[high] >= mid_value:
			high -= 1
		alist[low] = alist[high]
		# low右移
		while low < high and alist[low] < mid_value:
			low += 1
		alist[high] = alist[low]
	# 从循环退出时，low == high
	alist[low] = mid_value

	# 对low左边的列表执行快速排序
	quick_sort(alist, first, low - 1)
	# 对low右边的列表执行快速排序
	quick_sort(alist, low + 1, last)

归并排序（稳定）：
将列表拆分到每组只有一个元素，然后开始合并
时间复杂度：平均情况O(nlogn)，最好情况O(nlogn)，最坏情况O(nlogn)，辅助空间O(n)

def merge_sort(alist):
	"""归并排序"""
	n = len(alist)
	if n <= 1:
		return alist
	mid = n//2
	# left采用归并排序后形成的有序的新列表
	left_li = merge_sort(alist[:mid])

	# right采用归并排序后形成有序的新列表
	right_li = merge_sort(alist[mid:])
	
	# 将两个有序的子序列合并为一个整体
	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
		elif:
			redult.append(right_li[right_pointer])
			right_pointer += 1
	result += left_li[left_pointer:]
	result += right_li[right_pointer:]
	return result

二分查找：
必须是有序的顺序表，取中间位置比大小，直到找到位置

# 二分查找
# 递归的方式
def binary_search(alist, item):
	n = len(alist)
	if n >= 1:
		mid = n//2
		if alist[mid] == item:
			return True
		elif item < alist[mid]:
			return binary_search(alist[:mid], item)
		else:
			return binary_search(alist[mid+1:], item)
	return False

# 非递归的方式
def binary_search(alist, item):
	n = len(alist)
	first = 0
	last = n - 1
	while first <= last:
		mid = (first + last)//2
		if alsit[mid] == item:
			return True
		elif item < alist[mid]:
			last = mid - 1
		else:
			first = mid + 1
		return False