python学习之---排序算法

一、冒泡排序

主要思想：一轮“固定”一个元素的最终位置。
基本思想：给定一组排序序列，从前向后依次对相邻两个元素的值比较，将较大的数放到后面。这样，每一轮过后，都有这一轮的最大值移动到了这一轮的最后面。

def bubble_sort(arr):
	n = len(arr)	# 获取数组的长度
	# 外层循环控制比较的次数
	for i in range(n):
		# 内层循环进行相邻元素的比较
		for j in range(0, n-i+1):
			# 若当前元素大于下一个元素，则交换
			if arr[j] > arr[j+1]:
				arr[j], arr[j+1] = arr[j+1], arr[j]
	return arr

二、选择排序

选择排序算法通过选择和交换来实现排序，其排序流程如下：
1、首先从原始数组中选择最小的1个数据，将其和位于第1个位置的数据交换。
2、接着从剩下的n-1个数据中选择次小的1个元素，将其和第2个位置的数据交换
3、然后，这样不断重复，直到最后两个数据完成交换。最后，便完成了对原始数组的从小到大的排序。

def selection_sort(arr):
	n = len(arr)	# 数组长度
	# 外层循环控制未排序部分的起始位置
	for i in range(n):
		min_index = i	# 假设当前元素是最小值
		# 内层循环寻找未排序部分的最小值
		for j in range(i+1,n):
			if arr[j] < arr[min_index]:
				min_index = j	# 更新最小值索引
			# 将找到的最小值与当前元素交换
			arr[i], arr[min_index] = arr[min_index], arr[i]
	return arr

三、插入排序

步骤：
1、将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
2、从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

def insertion_sort(arr):
	n = len(arr)
	# 从第二个元素开始，假设第一个元素有序
	for i in range(1, n):
		key = arr[i]	# 当前待插入的元素
		j = i-1
		# 将大于key的元素向后移一位
		while j >= 0 and arr[j] > key:
			arr[j+1] = arr[j]	# 右移
			j -= 1
		arr[j+1] = key	# 将key插入合适的位置
	return arr
# 测试
arr = [12,11,13,5,6]
insertion_sort(arr)
print("排序后的数组：")
for i in range(len(arr)):
	print("%d"% arr[i])

四、合并排序

步骤：
1、先将无序序列利用二分法划分为子序列，直至每个子序列只有一个元素(单元素序列必有序)；
2、然后再对有序子序列逐步(两两)进行合并排序。合并方法是循环的将两个有序子序列当前的首元素进行比较，较小的元素取出，置入合并序列的左边空置位，直至其中一个子序列的最后一个元素置入合并序列中；
3、最后将另一个子序列的剩余元素按顺序逐个置入合并序列尾部即可完成排序。

def merge_sort(arr):
	if len(arr) > 1:
		mid = len(arr)//2	# 找到数组的中点
		L = arr[:mid]	# 左半部分
		R = arr[mid:]	# 右半部分
		# 递归排序左右两部分
		merge_sort(L)
		merge_sort(R)
		
		i = j = k = 0	# 初始化索引
		# 合并两个有序数组
		while i < len(L) and j < len(R):
			if L[i] < R[j]:
				arr[k] = L[i]
				i += 1
			else:
				arr[k] = R[j]
				j += 1
			k += 1
		# 检查是否有剩余的元素
		while i < len(L):
			arr[k] = L[i]
			i += 1
			k += 1
		while j < len(R):
			arr[k] = R[j]
			j += 1
			k += 1
	return arr 
		

五、快速排序

步骤：
1、首先设定一个分界值，通过该分界值将数组分成左右两部分。
2、将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
3、然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
4、重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

def quick_sort(arr):
	if len(arr) <= 1:
		return arr	# 若数组长度为1或0，则直接返回

	pivot = arr[len(arr)//2]	# 选择中间元素作为基准
	left = [x for x in arr if x < pivot]	# 小于基准的元素
	middle = [x for x in arr if x = pivot]	# 等于
	right = [x for x in arr if x > pivot]	# 大于

	# 递归调用
	return quick_sort(left) + middle + quick_sort(right)

六、测试所有排序算法

if __name__ == "__main__":
	sample_array = [64,34,25,12,22,11,90]
	print("原始数组：", sample_array)

	print("冒泡排序：",bubble_sort(sample_array.copy()))
	print("选择排序：",selection_sort(sample_array.copy()))
	print("插入排序：",insertion_sort(sample_array.copy()))
	print("合并排序：",merge_sort(sample_array.copy()))
	print("快速排序：",quick_sort(sample_array.copy()))