排序算法(python)

排序算法

冒泡排序

一次比较相邻的两个数,每轮之后末尾的数字是确定的。

  • 时间复杂度为 O ( n 2 ) O(n^2) O(n2),空间复杂度为 O ( 1 ) O(1) O(1),稳定。
python 复制代码
def BUB(nums):
	for i in range(len(nums)):
		count = 0
		for j in range(len(nums)-i-1):
			if nums[j] > nums[j+1]:
				nums[j], nums[j+1] = nums[j+1], nums[j]
				count += 1
		# count是为了记录该轮是否有修改的,若没有修改,则说明当前数组已经满足条件,不需要再进行交换了。
		if count == 0:
			break
	return nums

选择排序

选择排序是每轮在剩余的元素中,找到最小的元素交换位置。

  • 时间复杂度为 O ( n 2 ) O(n^2) O(n2),空间复杂度为 O ( 1 ) O(1) O(1),不稳定。
python 复制代码
def selection(nums):
	for i in range(len(nums)-1):
		for j in range(i+1, len(nums)):
			if nums[i] > nums[j]:
				nums[i], nums[j] = nums[j], nums[i]
	return nums

插入排序

插入排序是默认前面的序列是有序的,然后将后面的每个数字依次与前面有序的序列进行比较

  • 时间复杂度为 O ( n 2 ) O(n^2) O(n2),空间复杂度为 O ( 1 ) O(1) O(1),稳定。
python 复制代码
def insertSort(nums):
	for i in range(len(nums)-1):
		for j in range(i+1, 0, -1):
			if nums[j] < nums[j-1]:
				nums[j], nums[j-1] = nums[j-1], nums[j]
			else:
				break
	return nums

希尔排序

希尔排序是对插入排序的优化,它选择了一个增量(len(nums)//2),然后按照这个增量选取等差数列,每轮对每个等差数列进行排序,然后将增量缩小,重复进行排列,直到增量缩小为1。

  • 时间复杂度为 O ( n l o g 2 n ) O(nlog_2^n) O(nlog2n),空间复杂度为 O ( 1 ) O(1) O(1),稳定。
python 复制代码
def xier(nums):
	l = len(nums)
	gap = l//2
	while gap>0:
		for i in range(gap, l):
			temp = nums[i]
			j = i
			# j-gap就相当于等差数列进行排序比较
			while j-gap>0 and temp < nums[j-gap]:
				nums[j] = nums[j-gap]
				j = j-gap
			nums[j]=temp
		gap-=1
	return nums

归并排序

合并两个已经排好序的序列以得到结果。是一个递归的过程。

  • 时间复杂度为 O ( n l o g n ) O(nlogn) O(nlogn),空间复杂度为 O ( n ) O(n) O(n),稳定。
python 复制代码
# 合并两个有序的数组
def merge_two(s1,s2,s):
	i, j = 0, 0
	while (i+j) < len(s):
		# j==len(s2)时说明s2走完了,或者s1没走完并且s1中该位置是最小的
		if j==len(s2) or (i<len(s1) and s1[i] < s2[j]):
			s[i+j] = s1[i]
			i += 1
		else:
			s[i+j] = s2[j]
			j += 1
def merge(s):
	l = len(s)
	if l<2:
		return
	mid = l//2
	s1 = s[0:mid]
	s2 = s[mid:l]
	merge(s1)
	merge(s2)
	merge_two(s1, s2, s)

快速排序

快速排序需要一个基准元素,以及左右两个指针l,r,首先从右端元素开始与基准元素进行比较,找到比基准元素小的数字,放到左端,然后从左端开始寻找比右端大的元素放到r的位置。一轮之后,基准元素左端都是比基准元素小的,右端都是比基准元素大的。然后再依次遍历基准元素左边和右边的序列。

  • 时间复杂度为 O ( n l o g n ) O(nlogn) O(nlogn),空间复杂度为 O ( 1 ) O(1) O(1),不稳定。
python 复制代码
def quick_sort(nums, start, end):
	if start >= end:
		return
	pivot = nums[start]
	l, r = start, end
	while l<r:
		while l<r and nums[r] > pivot:
			r-=1
		nums[l] = nums[r]
		while l<r and nums[l] < pivot:
			l+=1
		nums[r] = nums[l]
	nums[l] = pivot
	quick_sort(nums, start, l)
	quick_sort(nums, l+1, end)
相关推荐
小沈熬夜秃头中୧⍤⃝7 分钟前
【贪心算法】No.1---贪心算法(1)
算法·贪心算法
CSXB998 分钟前
三十四、Python基础语法(文件操作-上)
开发语言·python·功能测试·测试工具
木向39 分钟前
leetcode92:反转链表||
数据结构·c++·算法·leetcode·链表
阿阿越41 分钟前
算法每日练 -- 双指针篇(持续更新中)
数据结构·c++·算法
亚图跨际1 小时前
MATLAB和Python及R潜变量模型和降维
python·matlab·r语言·生物学·潜变量模型
skaiuijing1 小时前
Sparrow系列拓展篇:对调度层进行抽象并引入IPC机制信号量
c语言·算法·操作系统·调度算法·操作系统内核
IT古董1 小时前
【机器学习】决定系数(R²:Coefficient of Determination)
人工智能·python·机器学习
德育处主任Pro1 小时前
『Django』APIView基于类的用法
后端·python·django
Star Patrick1 小时前
算法训练(leetcode)二刷第十九天 | *39. 组合总和、*40. 组合总和 II、*131. 分割回文串
python·算法·leetcode
武子康2 小时前
大数据-213 数据挖掘 机器学习理论 - KMeans Python 实现 距离计算函数 质心函数 聚类函数
大数据·人工智能·python·机器学习·数据挖掘·scikit-learn·kmeans